Print nested options by depth and polymorphic option code as overloads
Why
A nested match and a polymorphic function at a nested option failed tsc under -bs-emit-ts. The marker arm printed every depth as number, { readonly BS_PRIVATE_NESTED_SOME_NONE: number }, so no true declaration of valFromOption gave the payload back: at depth 0 it returns undefined, at depth d > 0 the marker of depth d - 1. And a function whose type parameter is an option's payload was bounded to the primitives, so getOr at 'a = option<int> (NestMatch.useNested) and Stdlib_Option.getOr at that instance (Memo.cached) had no signature.
modifiedRepresentation option under -bs-emit-ts
representation
Before
After
option<option<int>> ↦ undefined | number | { readonly BS_PRIVATE_NESTED_SOME_NONE: number }option<unit> ↦ undefined | void | { readonly BS_PRIVATE_NESTED_SOME_NONE: number } option<option<int>> ↦ undefined | number | { readonly BS_PRIVATE_NESTED_SOME_NONE: 0 }option<option<option<int>>> ↦ undefined | number | { …: 0 } | { …: 1 }option<unit> ↦ undefined | void | { readonly BS_PRIVATE_NESTED_SOME_NONE: 0 }option<'a> in a type declaration, or at an abstract payload ↦ undefined | a | { …: number }
ruleSome(v) is the marker of depth 0 when v is undefined, of depth d + 1 when v is the marker of depth d, and v otherwise (Primitiveoption.some); the depths are read off the payload's encoding, an option's, unit's, or a type that cannot hold undefined (no marker)
modifiedJS -bs-emit-ts polymorphic option code
let getOr = (o: option<'a>, d: 'a) => switch o { | Some(v) => v | None => d }
js
Before
After
export function getOr<a extends string | number | boolean | bigint>(o: (undefined | a), d: a): a { export function getOr<a extends string | number | boolean | bigint>(o: (undefined | a), d: a): a;export function getOr<a extends string | number | boolean | bigint>(o: (undefined | ( (undefined | a) | { readonly BS_PRIVATE_NESTED_SOME_NONE: 0 })), d: (undefined | a)): (undefined | a);export function getOr<a extends string | number | boolean | bigint>(o: (undefined | ( (undefined | a) | { readonly BS_PRIVATE_NESTED_SOME_NONE: 0 })), d: (undefined | a)): (undefined | a) {
modifiedJS -bs-emit-ts a function returning undefined alone
let useNestedFolded = () => getOr(Some(None), Some(3))js
Before
After
export function useNestedFolded(): (undefined | number) {export function useNestedFolded(): (undefined | number) { return;}}
The examples NestMatch (nested matches, getOr at a nested instance) and Memo (Stdlib_Option.getOr at 'a = option<int>) join the build test.
Review
- Why is each overload true? It is the function's signature at the instance
'a := option^k<a>, k = 0 or 1, withabounded to the primitives as before, printed by the same rule: the function's code is the code of every instance. The signature the body carries is the deepest instance's, which no caller sees; tsc checks the body there. - Why no conditional type for
Some<A>?Some<A>at an unboundedAis true only if no value but the runtime's markers owns the keyBS_PRIVATE_NESTED_SOME_NONE; a record type admits values owning further keys. The overloads hold at primitive payloads with no assumption. - What do the runtime declarations state?
Primitive_option.someandvalFromOption, andStdlib_Option.getOr, one signature per nesting of a primitive payload, up to an option of an option; each line audited against Primitive_option.res and Stdlib_Option.res.Stdlib_Option.mapkeeps its primitive signature. - Does this change genType's output? No: the marker hook answers "no marker" outside -bs-emit-ts, and the gentype tests' outputs are unchanged.