expanded version of the optional parameter example

[Mouvedia]

This resolves the concern raised in #111 by being more explicit.
For convenience, the specification assumes that undefined is read-only.

[Mouvedia]

@ericelliott if it's merged remember to squash it.

[ericelliott]

Those are not necessarily equivalent. I would assume that if present, an optional param will be of type Type, whereas if you explicitly pass undefined, the param may be present, but wouldn't conform to type Type.

The difference is subtle, but particularly interesting with named parameter objects:

const options = {
  foo: undefined,
  bar: 'bar'
};

// myFunc({ foo?: String, bar: String }) => NewThing
const resultA = myFunc(options) // Type error. If supplied, `foo` must be a string.

const resultB = myFunc({ bar: 'baz' }); // OK because `foo` isn't supplied.

We should address this in the spec, but I'm not sure which way to go on it. Thanks for bringing it up. =)

[Mouvedia]

@ericelliott the default is only used when nothing is passed. Arguments—in contrast with parameters—is what counts in that case. There's no argument when the default is used. There's nothing wrong with my addition in that regard. Your example has nothing to do with my addition.

e.g.

test = function (a, b = undefined) { console.dir(arguments); console.log(arguments.length); };
test(1);

[ericelliott]

Arguments—in contrast with parameters—is what counts in that case.

That's not really relevant. The runtime type checker is never going to see the parameter default value. Instead, it's going to essentially do this:

if (Object.hasOwnProperty(options.foo)) {
  if (isType(options.foo, expectedType)) return true;
  return false;
}
return true;

[Mouvedia]

I think we are talking about different things.

I am talking about

// (param1: Type, param2 = undefined: Type) => ReturnType
example1(arg1);

and you are talking about

// (param1: Type, param2: Type) => ReturnType
example2(arg1, undefined); // type error

@ericelliott Are you saying that we can't tell the difference between example(arg1); and example(arg1, undefined);?

If what you are saying were true it would mean that the type covers the argument and the default which wouldn't let us have a default of a different type than the type declared. @ericelliott Is that what you are scared of?

We don't need to set a separate type for the default because it is always implicit since defaults' values are known before hand.

[ericelliott]

and you are talking about

No, I'm not. Re-read the logic.

No, I'm not saying we can't tell the difference between example(arg1); and example(arg1, undefined); I'm saying we can, and we can even tell the difference between example({ arg1 }) and example({ arg1, arg2: undefined }) and that the difference is significant.

[Mouvedia]

Ill quote myself because it seems that you have missed my question:

If what you are saying were true it would mean that the type covers the argument and the default which wouldn't let us have a default of a different type than the type declared. @ericelliott Is that what you are scared of?

[Mouvedia]

I am closing this in favor of #118.