errors.log

  array
    Vector
      ✓ the<{ 0: number, 1: number, 2: number, length: 3 }, Vector<number, 3>>
      ✓ the<Vector<number | string, 3>, { 0: number, 1: number, 2: number, length: 3 } | { 0: string, 1: string, 2: string, length: 3 }>
      ✓ the<{ 0: number | string, 1: number | string, 2: number | string, length: 3 }, Vector<number | string, 3>>
      ✓ the<{ 0: number, 1: number, length: 2 } | { 0: number, 1: number, 2: number, length: 3 }, Vector<number, 2 | 3>>
    ArrayProp
      ✓ the<0, ArrayProp<Array<0>>>
      ✓ the<0 | 1, ArrayProp<Array<0 | 1>>>
      ✓ the<0 | 1, ArrayProp<Array<0> | Array<1>>>
    TupleProp
      ✓ the<0, TupleProp<[0], 0>>
      ✓ the<0, TupleProp<[0], 1>>
      ✓ the<number, TupleProp<number[], 0>>
    TupleHasIndex
      ✓ the<'1', TupleHasIndex<NumArr, 1>>
      ✓ the<'0', TupleHasIndex<NumArr, -1>>
      ✓ the<'0'|'1', TupleHasIndex<NumArr, -1|1>>
      ✓ the<'0'|'1', TupleHasIndex<NumArr | ['a'], 1>>
      × the<'1', TupleHasIndex<{a:1}, 'a'>>
      × the<'0', TupleHasIndex<{a:1}, 'b'>>
      × the<'1', TupleHasIndex<{ 1: "hi" }, 1>>
      × the<'0', TupleHasIndex<{ 1: "hi" }, -1>>
    IsArrayType
      ✓ the<'1', IsArrayType<NumArr>>
      ✓ the<'1', IsArrayType<any[]>>
      ✓ the<'0', IsArrayType<{ length: 2 }>>
    AppendNumObj
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c' }, AppendNumObj<{ 0: 'a', 1: 'b' }, 'c'>>
    ConcatNumObjs
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c', 3: 'd' }, ConcatNumObjs<{ 0: 'a', 1: 'b' }, { 0: 'c', 1: 'd' }>>
    Length
      ✓ the<3, Length<TupleToObject<TestArr>>>
      ✓ the<3, Length<TestArr>>
      ✓ the<0, Length<any[]>>
      ✓ the<2, Length<{ 0: 'a', 1: 'b' }>>
      ✓ the<0|3, Length<any[]|TestArr>>
    IncIndexNumbObj
      ✓ the<{ 2: 'a', 3: 'b', length: 2 }, IncIndexNumbObj<{ 0: 'a', 1: 'b' }, 2>>
    ListFrom
      ✓ the<{ 0: 'c', 1: 'd', length: 2 }, ListFrom<{ 0: 'a', 1: 'b', 2: 'c', 3: 'd', length: 4 }, 2>>
    ListTo
      ✓ the<{ 0: 'a', 1: 'b', length: 2 }, ListTo<{ 0: 'a', 1: 'b', 2: 'c', 3: 'd', length: 4 }, 2>>
    Reverse
      ✓ the<{ 0: 'b', 1: 'a', length: 2 }, Reverse<['a', 'b']>>
    TupleLastElem
      ✓ the<'c', TupleLastElem<TestArr>>
    TupleLastIndex
      ✓ the<2, TupleLastIndex<TestArr>>
      ✓ the<-1, TupleLastIndex<any[]>>
    IsTuple
      ✓ the<'1', IsTuple<[0]>>
      ✓ the<'0', IsTuple<string[]>>

  boolean
    Not
      ✓ the<'1', Not<'0'>>
      ✓ the<'0', Not<'1'>>
      - the<Bool, Not<'2'>>
      - the<'0', Not<'true'>>
      - the<'1', Not<'false'>>
      - the<never, Not<any>>
      ✓ the<Bool, Not<never>>
      - the<'0', Not<true>>
      - the<'1', Not<false>>
    And
      ✓ the<'1', And<'1', '1'>>
      ✓ the<'0', And<'0', '1'>>
    Or
      ✓ the<'1', Or<'1', '0'>>
      ✓ the<'0', Or<'0', '0'>>
    UnionHasKey
      ✓ the<'1', UnionHasKey<Bool,'0'>>
      ✓ the<'1', UnionHasKey<Bool,'1'>>
      ✓ the<'1', UnionHasKey<Bool,'0'> | UnionHasKey<Bool,'1'>>
      ✓ the<'1', And<UnionHasKey<Bool,'0'>, UnionHasKey<Bool,'1'>>>
    Indeterminate
      ✓ the<'1', Indeterminate<Bool>>
      ✓ the<'0', Indeterminate<'0'>>
      ✓ the<'0', Indeterminate<'1'>>
    Determinate
      ✓ the<'0', Determinate<Bool>>
      ✓ the<'1', Determinate<'0'>>
      ✓ the<'1', Determinate<'1'>>
    DefinitelyYes
      ✓ the<'0', DefinitelyYes<Bool>>
      ✓ the<'0', DefinitelyYes<'0'>>
      ✓ the<'1', DefinitelyYes<'1'>>
    DefinitelyNo
      ✓ the<'0', DefinitelyNo<Bool>>
      ✓ the<'1', DefinitelyNo<'0'>>
      ✓ the<'0', DefinitelyNo<'1'>>
    IsTruthy
      ✓ the<'1', IsTruthy<true>>
      ✓ the<'0', IsTruthy<false>>
      ✓ the<'1', IsTruthy<123>>
      ✓ the<'0', IsTruthy<0>>
      ✓ the<IsTruthy<'s' | null>, Bool>
    IsFalsy
      ✓ the<'0', IsFalsy<true>>
      ✓ the<'1', IsFalsy<false>>
      ✓ the<'0', IsFalsy<123>>
      ✓ the<'1', IsFalsy<0>>
      ✓ the<IsFalsy<'s' | null>, Bool>

  cast
    NumberToString
      ✓ the<'3', NumberToString[3]>
      ✓ the<'3', NumberToString['3']>
      × the<'3', NumberToString<3>>
      ✓ the<string, NumberToString[number]>
    StringToNumber
      ✓ the<3, StringToNumber['3']>
      ✓ the<3, StringToNumber[3]>
      ✓ the<number, StringToNumber[string]>
    TupleToUnion
      ✓ the<"a" | "b" | "c", TupleToUnion<TestArr>>
    TupleIndicesToUnion
      ✓ the<0 | 1 | 2, TupleIndicesToUnion<TestArr>>
    TupleToObject
      ✓ the<{ 0: "a"; 1: "b"; 2: "c"; }, TupleToObject<TestArr>>
    TupleToList
      ✓ the<{ 0: "a"; 1: "b"; 2: "c"; length: 3; }, TupleToList<TestArr>>
    NumObjToList
      ✓ the<{ 0: 'a', 1: 'b', length: 2 }, NumObjToList<{ 0: 'a', 1: 'b' }>>
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c', length: 3 }, NumObjToList<TupleToObject<TestArr>>>
    ListToNumObj
      ✓ the<{ 0: 'a', 1: 'b' }, ListToNumObj<{ 0: 'a', 1: 'b', length: 2 }>>
    BoolToString
      ✓ the<'1', BoolToString<true>>

  comp
    StringsEqual
      ✓ the<'1', StringsEqual<'a', 'a'>>
      ✓ the<'0', StringsEqual<'a', 'b'>>
    NumbersEqual
      ✓ the<'1', NumbersEqual<123, 123>>
      ✓ the<'0', NumbersEqual<123, 456>>
      × the<'1', NumbersEqual<123, '123'>>
      × the<'1', NumbersEqual<'123', 123>>
      ✓ the<'0', NumbersEqual<0, 5>>
      ✓ the<'0', NumbersEqual<5, 0>>
    Gt
      ✓ the<'1', Gt<3, 2>>
      ✓ the<'0', Gt<2, 3>>
      ✓ the<'0', Gt<3, 3>>
    Lt
      ✓ the<'0', Lt<3, 2>>
      ✓ the<'1', Lt<2, 3>>
      ✓ the<'0', Lt<3, 3>>
    Gte
      ✓ the<'1', Gte<3, 2>>
      ✓ the<'0', Gte<2, 3>>
      ✓ the<'1', Gte<3, 3>>
    Lte
      ✓ the<'0', Lte<3, 2>>
      ✓ the<'1', Lte<2, 3>>
      ✓ the<'1', Lte<3, 3>>
    Max
      ✓ the<6, Max<3, 6>>
      ✓ the<5, Max<5, 2>>
    Min
      ✓ the<3, Min<3, 6>>
      ✓ the<2, Min<5, 2>>

  function
    Fn
      ✓ the<(v: number) => string, Fn<[number], string>>
    Arguments
      ✓ the<[boolean, string], Arguments<(<S extends string>(a: boolean, s: S) => number)>>
    Argument
      ✓ the<1, Argument<0, (a: 1, b: × => 8>>
      ✓ the<2, Argument<1, (a: 1, ...args: 2[]) => 8>>
      ✓ the<2, Argument<1, (a: 1, b: 2, ...args: 3[]) => 8>>

  number
    Inc
      ✓ the<2, Inc[1]>
    Dec
      ✓ the<1, Dec[2]>
    Add
      ✓ the<5, Add<3, 2>>
    Subtract
      ✓ the<1, Subtract<3, 2>>
    Mult
      ✓ the<6, Mult<3, 2>>
    Pow
      ✓ the<9, Pow<3, 2>>
      ✓ the<8, Pow<2, 3>>
    DivFloor
      ✓ the<2, DivFloor<5, 2>>
    Modulo
      ✓ the<1, Modulo<5, 2>>

  object
    Keyed
      ✓ the<{a:'a',b:'b'}, Keyed<{a:1,b:2}>>
    KeyedSafe
      ✓ the<{a:'a',b:'b'} & Obj<never>, KeyedSafe<{a:1} & {b:2}>>
    ObjectHasKey
      ✓ the<'1', ObjectHasKey<{a:1}, 'a'>>
      ✓ the<'0', ObjectHasKey<{a:1}, 'b'>>
      ✓ the<'0'|'1', ObjectHasKey<{a?:1}, 'a'>>
      × the<'1', ObjectHasKey<NumArr, 1>>
      × the<'0', ObjectHasKey<NumArr, -1>>
      ✓ the<'0', ObjectHasKey<{ a: 1 }, "toString">>
    HasKey
      ✓ the<'0', HasKey<any[], 2>>
      ✓ the<'1', HasKey<NumArr, 2>>
      ✓ the<'0', HasKey<NumArr, 5>>
      ✓ the<'1', HasKey<{ a: 1 }, 'a'>>
      ✓ the<'0', HasKey<{ a: 1 }, 'b'>>
    ObjectHasKeySafe
      ✓ the<'1', ObjectHasKeySafe<{ a: 1 }, 'a'>>
      ✓ the<'0', ObjectHasKeySafe<{ a: 1 }, 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1 }, 'a' | 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'a'>>
      ✓ the<'0', ObjectHasKeySafe<{ a: 1, toString(): string }, 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'a' | 'b'>>
      ✓ the<'0', ObjectHasKeySafe<{ a: 1 }, 'toString'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1 }, 'toString' | 'a'>>
      ✓ the<'0', ObjectHasKeySafe<{ a: 1 }, 'toString' | 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1 }, 'toString' | 'a' | 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'toString'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'toString' | 'a'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'toString' | 'b'>>
      ✓ the<'1', ObjectHasKeySafe<{ a: 1, toString(): string }, 'toString' | 'a' | 'b'>>
    ObjectProp
      ✓ the<1, ObjectProp<{ a: 1 }, 'a'>>
      ✓ the<never, ObjectProp<{ a: 1 }, 'b'>>
      ✓ the<never, ObjectProp<{ a: 1 }, 'toString'>>
      ✓ the<1, ObjectProp<{ a: 1, toString(): string }, 'a'>>
      ✓ the<never, ObjectProp<{ a: 1, toString(): string }, 'b'>>
      ✓ the<() => string, ObjectProp<{ a: 1, toString(): string }, 'toString'>>
    Omit
      ✓ the<{ b: number, c: boolean }, Omit<Item1, "a">>
      ✓ the<'b'|'c'|'toString', Exclude<keyof ItemA, "a">>
      ✓ the<{ b: number, c: boolean, toString(): string }, Omit<ItemA, "a">>
    Overwrite
      ✓ the<{ a: number, b: number, c: boolean }, Overwrite<Item1, Item2>>
    IntersectionObjectKeys
      ✓ the<'b', IntersectionObjectKeys<Obj1, Obj2>>
    IntersectionObjects
      ✓ the<{ b: 2 }, IntersectionObjects<Obj1, Obj2>>
      ✓ the<{ b: 'X' }, IntersectionObjects<Obj2, Obj1>>
    ObjectValsToUnion
      ✓ the<1|2, ObjectValsToUnion<Obj1>>
    Simplify
      ✓ the<{ a: 1, b: 2}, Simplify<{ a: 1 } & { b: 2}>>
    Swap
      ✓ the<{ b: 'a', d: 'c' }, Swap<{ a: 'b', c: 'd' }>>
    toString experimenting
      ✓ the<{ a: 1, foo: () => string, toString: () => string }, Omit<abc, "b">>
      ✓ the<{ a: 1, b: 2, foo: () => string }, Omit<abc, "toString">>
      ✓ the<abc, Simplify<abc & { "b": never }>>
      ✓ the<{ a: 1, b: any, foo: () => string, toString: () => string }, Simplify<abc & { "b": any }>>
      ✓ the<abc, Simplify<abc & { "toString": never }>>
      ✓ the<{ a: 1, b: 2, foo: () => string, toString: any }, Simplify<abc & { "toString": any }>>
      ✓ the<abc, Simplify<abc & { "foo": never }>>
      ✓ the<{ a: 1, b: 2, foo: any, toString: () => string }, Simplify<abc & { "foo": any }>>
      ✓ the<{ a: 1, b: never, foo: () => string, toString: () => string }, Overwrite<abc, { "b": never }>>
      ✓ the<{ a: 1, b: any, foo: () => string, toString: () => string }, Overwrite<abc, { "b": any }>>
      ✓ the<{ a: 1, b: 2, foo: () => string }, Overwrite<abc, { "toString": never }>>
      ✓ the<{ a: 1, b: 2, foo: () => string, toString: any }, Overwrite<abc, { "toString": any }>>
      ✓ the<{ a: 1, b: 2, foo: never, toString: () => string }, Overwrite<abc, { "foo": never }>>
      ✓ the<{ a: 1, b: 2, foo: any, toString: () => string }, Overwrite<abc, { "foo": any }>>
      ✓ the<abc, Simplify<abc & { "toString": never }>>
      ✓ the<'1', ObjectHasStringIndex<{ [k: string]: 123 }>>
      ✓ the<'0', ObjectHasStringIndex<{ a: 123 }>>
    StripIndex
      ✓ the<StripIndex<{ a: 1, [k: string]: number }>, { a: 1 }>
    Jsonified
      ✓ the<{ b: 'a' }, Jsonified<{ b: 'a', d: undefined, f: () => void }>>
    IntersectValueOf
      ✓ IntersectValueOf
    DeepWiden
      ✓ the<{ a: number }, DeepWiden<{ a: 1 }>>
    DeepPartial
      ✓ the<{ a?: { b?: 1 } }, DeepPartial<{ a: { b: 1 } }>>
      × the<1, DeepPartial<{ a: [{ b: 1 }] }>['a'][0]['b']>
    DeepRequired
      ✓ the<{ a: { b: 1 } }, DeepRequired<{ a?: { b?: 1 } }>>
    Mutable
      ✓ the<{ a: 1 }, Mutable<{ readonly a: 1 }>>
    DeepMutable
      ✓ the<{ a: { b: 1 } }, DeepMutable<{ readonly a: { readonly b: 1 } }>>
    DeepAssert
      ✓ the<{ a: 1 }, DeepAssert<{ a: 1|null }>>
    DeepReadonly
      ✓ still allows reading
      × disallows writing - layer 0
      × disallows writing - layer 1
      × disallows writing - layer 2
      × strips out methods
    LiteralPropNames
      ✓ the<'a', LiteralPropNames<{ a: 1, [k: string]: number }>>
    LiteralProps
      ✓ the<{ a: 1 }, LiteralProps<{ a: 1, [k: string]: number }>>
    FunctionPropNames
      ✓ the<'f', FunctionPropNames<{ a: 1, f: () => void }>>
    FunctionProps
      ✓ the<{ f: () => void }, FunctionProps<{ a: 1, f: () => void }>>
    NonFunctionPropNames
      ✓ the<'a', NonFunctionPropNames<{ a: 1, f: () => void }>>
    NonFunctionProps
      ✓ the<{ a: 1 }, NonFunctionProps<{ a: 1, f: () => void }>>
    MatchingPropNames
      ✓ the<'f', MatchingPropNames<{ a: 1, f: true }, boolean>>
    MatchingProps
      ✓ the<{ f: true }, MatchingProps<{ a: 1, f: true }, boolean>>
    NonMatchingPropNames
      ✓ the<'a', NonMatchingPropNames<{ a: 1, f: true }, boolean>>
    NonMatchingProps
      ✓ the<{ a: 1 }, NonMatchingProps<{ a: 1, f: true }, boolean>>
    OptionalPropNames
      ✓ the<'a', OptionalPropNames<{ a?: 1, b: 2 }>>
    OptionalProps
      ✓ the<{ a?: 1 }, OptionalProps<{ a?: 1, b: 2 }>>
    RequiredPropNames
      ✓ the<'b', RequiredPropNames<{ a?: 1, b: 2 }>>
    RequiredProps
      ✓ the<{ b: 2 }, RequiredProps<{ a?: 1, b: 2 }>>
    Spread
      ✓ the<{ a: number, b: number, c: boolean }, Spread<Item1, Item2>>
      ✓ the<AB, Spread<A, B>>
    ObjectHasNumberIndex
      ✓ the<'0', ObjectHasNumberIndex<{ 0: 'a' }>>
      ✓ the<'0', ObjectHasNumberIndex<['a']>>
      ✓ the<'1', ObjectHasNumberIndex<{ [i: number]: 'a' }>>
      ✓ the<'1', ObjectHasNumberIndex<'a'[]>>
    ObjectHasElem
      ✓ the<'1', ObjectHasElem<{ a: 1 }, 1>>
      ✓ the<'0', ObjectHasElem<{ a: 1 }, 0>>
    ObjectNumberKeys
      ✓ the<'0'|'1', ObjectNumberKeys<['a','b']>>
      ✓ the<'0'|'1', ObjectNumberKeys<{0:'a',1:'b',length:2}>>

  ramda
    PathFn
      ✓ the<'e', PathFn<{ a: { b: ['c', { d: 'e' }] } }, ['a', 'b', '1', 'd']>>
      × path
    PathOrFn
      ✓ the<'e', PathOrFn<{ a: { b: ['c', { d: 'e' }] } }, "oh", ['a', 'b', 1, 'd']>>
      ✓ the<'oh', PathOrFn<{ a: { b: ['c', { d: 'e' }] } }, "oh", ['a', 'b', 4]>>
    MergeAllFn
      ✓ the<{ a: 1, b: 3, c: 4, d: 5 }, MergeAllFn<[{ a: 1, b: 2 }, { b: 3, c: 4 }, { d: 5 }]>>
    FromPairsFn
      ✓ the<{ a: 5, b: 2, c: 3 }, FromPairsFn<[['a', 1], ['b', 2], ['c', 3], ['a', 5]]>>
    ZipObjectFn
      ✓ the<{ a: 1, b: 2, c: 3 }, ZipObjectFn<['a', 'b', 'c'], [1, 2, 3]>>
    #12838
      × identity
      × compose + generics
      × pipe + generics
      × compose + generics: concrete type first
      × pipe + generics: concrete type first
      × compose + generics: concrete type last
      × pipe + generics: concrete type last

  stdlib
    Partial
      ✓ the<{ a?: 1, b?: 2 }, Partial<{ a: 1, b: 2 }>>
    Readonly
      ✓ the<{ readonly a: 1 }, Readonly<{ a: 1 }>>
    Pick
      ✓ the<{ a: 1 }, Pick<{ a: 1, b: 2 }, 'a'>>
    Record
      ✓ the<{ a: 1, b: 1 }, Record<'a' | 'b', 1>>
    Exclude
      ✓ the<1|2, Exclude<1|2|3, 3|4>>
    Extract
      ✓ the<2|3, Extract<1|2|3, 2|3|4>>
    NonNullable
      ✓ the<1, NonNullable<1 | null>>
    ReturnType
      ✓ the<string, ReturnType<() => string>>
    InstanceType
      ✓ the<string, InstanceType<new () => string>>
      ✓ the<MyClass, InstanceType<typeof MyClass>>
      Required
        ✓ the<{ a: 1 }, Required<{ a?: 1 }>>

  built-in syntax
    |
      ✓ the<1|2, 2>
    &
      ✓ the<1, 1&2>
    []
      ✓ the<1, {a:1}['a']>
    keyof
      ✓ the<'a'|'b', keyof { a: 1, b: 2 }>
    in
      ✓ the<{ a: 'a' }, { [P in 'a']: P }>
    extends
      ✓ the<1, true extends boolean ? 1 : 0>

  tuple
    AppendList
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c', length: 3 }, AppendList<{ 0: 'a', 1: 'b', length: 2 }, 'c'>>
    ConcatLists
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c', 3: 'd', length: 4 }, ConcatLists<{ 0: 'a', 1: 'b', length: 2 }, { 0: 'c', 1: 'd', length: 2 }>>
    LengthList
      ✓ the<2, LengthList<{ 0: 'a', 1: 'b', length: 2 }>>
    ReverseList
      ✓ the<{ 0: 'b', 1: 'a', length: 2 }, ReverseList<['a', 'b']>>
    IncIndex
      ✓ the<{ 2: 'a', 3: 'b', length: 2 }, IncIndex<{ 0: 'a', 1: 'b', length: 2 }, 2>>
    DecIndex
      ✓ the<{ 0: 'a', 1: 'b', length: 2 }, DecIndex<{ 2: 'a', 3: 'b', length: 2 }, 2>>
    ZeroIndex
      ✓ the<{ 0: 'a', 1: 'b', length: 2 }, ZeroIndex<{ 2: 'a', 3: 'b', length: 2 }>>
    Prepend
      ✓ the<{ 0: 'a', 1: 'b', 2: 'c', length: 3 }, Prepend<{ 0: 'b', 1: 'c', length: 2 }, 'a'>>
    ListTail
      ✓ the<'c', ListTail<{ 0: 'a', 1: 'b', 2: 'c', length: 3 }>>
    DifferenceLists
      ✓ the<{ 0: 'c', 1: 'd', length: 2 }, DifferenceLists<{ 0: 'a', 1: 'b', 2: 'c', 3: 'd', length: 4 }, { 0: 123, 1: 456, length: 2 }>>

  type
    Xor
      ✓ the<never, Xor<string, number, boolean>>
      ✓ the<{ name: 's' }, Xor<{ name: 's' }>>
      ✓ the<never, Person<{ name: 's', firstname: 'f', lastname: 'l' }>>
    Matches
      ✓ the<'1', Matches<1, number>>
      ✓ the<'1', Matches<number, number>>
      ✓ the<'0', Matches<false, number>>
    TypesEqual
      ✓ the<'0', TypesEqual<string, number>>
      ✓ the<'1', TypesEqual<string, string>>
    InstanceOf
      ✓ the<'1', InstanceOf<1, number>>
      ✓ the<'0', InstanceOf<number, number>>
      ✓ the<'0', InstanceOf<false, number>>
    Awaited
      ✓ the<1, Awaited<1>>
      ✓ the<1, Awaited<Promise<1>>>
      ✓ the<1, Awaited<Promise<Promise<1>>>>
      ✓ the<1, Awaited<1 | Promise<1>>>
    Flatten
      ✓ the<1, Flatten<1>>
      ✓ the<1, Flatten<[1, 1]>>
      ✓ the<1, Flatten<[1, [1]]>>
    Widen
      ✓ the<Widen<1>, number>
      ✓ the<Widen<true>, boolean>
      ✓ the<Widen<'s'>, string>
    DiscriminateUnion
      ✓ the<Rectangle, DiscriminateShape<'rectangle'>>
    Const
      ✓ the<1, Const<1, 2>>

  util
    UnionHasKey
      ✓ the<'1', UnionHasKey<'a'|'b', 'b'>>
      ✓ the<'0', UnionHasKey<'a'|'b', 'c'>>
      ✓ the<'1', UnionHasKey<'a'|'b', 'a'|'b'>>
      ✓ the<'0', UnionHasKey<'a'|'b', 'c'|'d'>>
      ✓ the<'0'|'1', UnionHasKey<'a'|'b', 'b'|'c'>>
      ✓ the<'1', UnionHasKey<'a'|'b'|'toString', 'toString'>>
      ✓ the<'0', UnionHasKey<'a'|'b', 'toString'>>
    UnionToObject
      ✓ the<{ b: 'b', c: 'c' }, UnionToObject<'b' | 'c'>>
    UnionContained
      ✓ the<'1', UnionContained<never, 'a'>>
      ✓ the<'1', UnionContained<'a', 'a'>>
      ✓ the<'0', UnionContained<'b', 'a'>>
      ✓ the<'0', UnionContained<'a' | 'b', 'a'>>
    UnionEmpty
      ✓ the<'1', UnionEmpty<never>>
      ✓ the<'0', UnionEmpty<'a'>>
      ✓ the<'0', UnionEmpty<'a' | 'b'>>
      ✓ the<'0', UnionEmpty<'toString'>>
      ✓ the<'0', UnionEmpty<'toString' | 'a'>>
    UnionsOverlap
      ✓ the<'1', UnionsOverlap<'a', 'a' | 'b'>>
      ✓ the<'0', UnionsOverlap<'a', 'c'>>
    IsUnion
      ✓ the<'1', IsUnion<'a' | 'b'>>
      ✓ the<'0', IsUnion<'a'>>
      ✓ the<'0', IsUnion<never>>
      ✓ the<'1', IsUnion<'a' | undefined>>

  util
    the
      ✓ works with matching types
      × fails with clashing types
      × protects from never when flipped
      × protects from any
    If
      ✓ has then
      ✓ has else
    Intersection
      ✓ intersects


  291 passing (80ms)
  6 pending
  25 failing

  × array TupleHasIndex the<'1', TupleHasIndex<{a:1}, 'a'>>:
     Error: No semantic failures
  

  × array TupleHasIndex the<'0', TupleHasIndex<{a:1}, 'b'>>:
     Error: No semantic failures
  

  × array TupleHasIndex the<'1', TupleHasIndex<{ 1: "hi" }, 1>>:
     Error: No semantic failures
  

  × array TupleHasIndex the<'0', TupleHasIndex<{ 1: "hi" }, -1>>:
     Error: No semantic failures
  

  × cast NumberToString the<'3', NumberToString<3>>:
     Error: No semantic failures
  

  × comp NumbersEqual the<'1', NumbersEqual<123, '123'>>:
     Error: No semantic failures
  

  × comp NumbersEqual the<'1', NumbersEqual<'123', 123>>:
     Error: No semantic failures
  

  × object ObjectHasKey the<'1', ObjectHasKey<NumArr, 1>>:
     Error: No semantic failures
  

  × object ObjectHasKey the<'0', ObjectHasKey<NumArr, -1>>:
     Error: No semantic failures
  

  × object DeepPartial the<1, DeepPartial<{ a: [{ b: 1 }] }>['a'][0]['b']>:
     TypeError: Cannot read property 'a' of null
  

  × object DeepReadonly disallows writing - layer 0:
     Error: No matching semantic failures, expected "read-only"!
  

  × object DeepReadonly disallows writing - layer 1:
     Error: No matching semantic failures, expected "only permits reading"!
  

  × object DeepReadonly disallows writing - layer 2:
     Error: No matching semantic failures, expected "read-only"!
  

  × object DeepReadonly strips out methods:
     Error: No matching semantic failures, expected "does not exist"!
  

  × ramda PathFn path:
     ReferenceError: path is not defined
  

  × ramda #12838 identity:
     TypeError: identity is not a function
  

  × ramda #12838 compose + generics:
     TypeError: compose is not a function
  

  × ramda #12838 pipe + generics:
     TypeError: pipe is not a function
  

  × ramda #12838 compose + generics: concrete type first:
     TypeError: compose is not a function
  

  × ramda #12838 pipe + generics: concrete type first:
     TypeError: pipe is not a function
  

  × ramda #12838 compose + generics: concrete type last:
     TypeError: compose is not a function
  

  × ramda #12838 pipe + generics: concrete type last:
     TypeError: pipe is not a function
  

  × util the fails with clashing types:
     Error: No matching semantic failures, expected "does not satisfy"!
  

  × util the protects from never when flipped:
     Error: No matching semantic failures, expected "does not satisfy"!
  

  × util the protects from any:
     Error: No matching semantic failures, expected "does not satisfy"!