More idiomatic optional properties on runtime InterfaceCombinator output

[mmkal]

It looks like from gcanti/io-ts#140 that it's non-trivial to declare a key as optional based on properties of the value, although I still hope that there'll be some sort of TypeScript 2.8 magic that makes it possible. But given that io-ts-codegen is generating types as a string, it should be possible to do better than this:

t.printRuntime(t.interfaceCombinator([t.property('foo', t.stringType, true)]))

// outputs
t.interface({
  foo: t.union([
    t.string,
    t.undefined
  ])
})

by using the isOptional flag on the PropertyCombinator. Changing printRuntimeInterfaceCombinator to something like this would maybe do the trick:

function printRuntimeInterfaceCombinator(interfaceCombinator: InterfaceCombinator, i: number): string {
  let requiredProperties: Property[] = []
  let optionalProperties: Property[] = []
  interfaceCombinator.properties.forEach(p => p.isOptional ? optionalProperties.push(p) : requiredProperties.push(p))
  
  if (requiredProperties.length > 0 && optionalProperties.length > 0) {
    return printRuntimeIntersectionCombinator(intersectionCombinator([
      exports.interfaceCombinator(requiredProperties),
      partialCombinator(optionalProperties),
    ]), i)
  }
  
  if (optionalProperties.length > 0) {
    return printRuntimePartialCombinator(partialCombinator(optionalProperties), i)
  }
  
  let s = 't.interface({\n'
  s += interfaceCombinator.properties.map(p => printRuntimeProperty({ ...p, isOptional: false }, i + 1)).join(',\n')
  s += `\n${indent(i)}}`
  s = addRuntimeName(s, interfaceCombinator.name)
  s += ')'
  return s
}

then you get fairly sensible output, at least until optional values can become more natural in io-ts itself:

return [
  t.printRuntime(t.interfaceCombinator([t.property('foo', t.stringType, true)])),
  t.printRuntime(t.interfaceCombinator([t.property('foo', t.stringType, true), t.property('bar', t.numberType)])),
  t.printRuntime(t.interfaceCombinator([t.property('foo', t.stringType), t.property('bar', t.numberType)])),
].join('\n\n')

// outputs:
t.partial({
  foo: t.string
})

t.intersection([
  t.interface({
    bar: t.number
  }),
  t.partial({
    foo: t.string
  })
])

t.interface({
  foo: t.string,
  bar: t.number
})

Advantages being 1) that the optional properties are truly optional, and don't have to be explicitly assigned to undefined, and 2) it's more readable than seeing t.union([t.blah, t.undefined]) everywhere.

If you like the idea, feel free to just take the code straight from here. Or I could open a PR with something along these lines (and add a couple of tests).

[gcanti]

@mmkal looks good to me, @giogonzo what do you think?

[giogonzo]

@mmkal @gcanti makes a lot of sense, wanted this myself for a while. Thanks!

[gcanti]

Closing via #27