inferred-types 0.36.4 → 0.37.1

package/tests/Where.spec.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Expect, Equal } from "@type-challenges/utils";
-import { Where, WhereNot } from "../src/types/Where";
-
-describe("Where<T,U> and WhereNot<T,U> type utility", () => {
-  it("readonly string array works correctly", () => {
-    const arr = ["foo", "bar", "baz"] as const;
-    type A = typeof arr;
-    type B = Where<A, `ba${string}`>;
-    type F = WhereNot<A, `ba${string}`>;
-
-    type cases = [
-      //
-      Expect<Equal<B, "bar" | "baz">>,
-      Expect<Equal<F, "foo">>
-    ];
-
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("object with literal keys works", () => {
-    const arr = { foo: true, bar: true, baz: true } as const;
-    type A = typeof arr;
-    type B = Where<A, `ba${string}`>;
-    type F = WhereNot<A, `ba${string}`>;
-
-    type cases = [
-      //
-      Expect<Equal<B, "bar" | "baz">>,
-      Expect<Equal<F, "foo">>
-    ];
-
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-});

package/tests/arrayToKeyLookup-spec.ts

@@ -1,17 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect } from "@type-challenges/utils";
-import { arrayToKeyLookup } from "../src/runtime";
-
-describe("arrayToKeyLookup()", () => {
-  it("simple string array is converted", () => {
-    const lookup = arrayToKeyLookup("foo", "bar", "baz");
-    expect(lookup.foo).toBe(true);
-    expect(lookup.bar).toBe(true);
-    expect(lookup.baz).toBe(true);
-
-    type cases = [Expect<Equal<typeof lookup, Record<"foo" | "bar" | "baz", true>>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/arrayToObject-spec.ts

@@ -1,115 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Equal, Expect, ExpectExtends } from "@type-challenges/utils";
-import {
-  ArrayConverter,
-  arrayToObject,
-  GeneralDictionary,
-  UniqueDictionary,
-  defineType,
-  keys,
-} from "../src/runtime";
-
-const foo = { name: "foo", age: 123, color: "red" } as const;
-const foo2 = { name: "foo", age: 44, color: "orange" } as const;
-const bar = { name: "bar", age: 456, color: "blue" } as const;
-const baz = { name: "baz", age: 42, color: "green" } as const;
-
-describe("arrayToObject => ", () => {
-  it("partial application of arrayToObject()", () => {
-    const t1 = arrayToObject("name", false);
-    type T1 = typeof t1;
-    const t2 = arrayToObject("name", true);
-    type T2 = typeof t2;
-    const t3 = arrayToObject("name");
-    type T3 = typeof t3;
-
-    type cases = [
-      // literal statements about uniqueness are conveyed in partial application
-      Expect<Equal<T1, ArrayConverter<"name", false>>>,
-      Expect<Equal<T2, ArrayConverter<"name", true>>>,
-      // the default case is correctly set to true
-      Expect<Equal<T3, ArrayConverter<"name", true>>>,
-
-      // The response types for each type is as expected
-      Expect<ExpectExtends<GeneralDictionary<"name", any, any>, ReturnType<T1>>>,
-      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T2>>>,
-      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T3>>>
-    ];
-
-    const cases: cases = [true, true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("arrayToObject() is able to operate on unique and non-unique types", () => {
-    // first test where name is unique
-    const arr1 = [foo, bar, baz];
-    const dict1 = arrayToObject("name")(arr1);
-
-    expect(dict1.foo).toBe(foo);
-    expect(dict1.bar).toBe(bar);
-    expect(dict1.baz).toBe(baz);
-
-    // now test where name is not unique
-    const arr2 = [foo, foo2, bar, baz];
-    const dict2 = arrayToObject("name")(arr2);
-
-    expect(dict2.foo).toBe(foo2);
-    expect(dict2.bar).toBe(bar);
-    expect(dict2.baz).toBe(baz);
-
-    // because we've stated that items are _not_ unique
-    // we should expect results to be an array
-    const dict3 = arrayToObject("name", false)(arr2);
-
-    expect(Array.isArray(dict3.foo)).toBe(true);
-    expect(Array.isArray(dict3.bar)).toBe(true);
-    expect(Array.isArray(dict3.baz)).toBe(true);
-
-    type SomeFoo = typeof foo | typeof foo2;
-
-    type cases = [
-      // both unique and non-unique have the same keys
-      Expect<Equal<keyof typeof dict1, "foo" | "bar" | "baz">>,
-      Expect<Equal<keyof typeof dict2, "foo" | "bar" | "baz">>,
-      // with a unique type for "foo" we get a literal definition
-      Expect<Equal<typeof dict1["foo"], typeof foo>>,
-      // however when we passed in two "types" for "foo" we get a union
-      Expect<Equal<typeof dict2["foo"], SomeFoo>>,
-      // once we state that foo is not unique, the type expanded to an array
-      Expect<Equal<typeof dict3["foo"], SomeFoo[]>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("type support of wide an narrow types", () => {
-    const r1 = defineType({ id: 1, slug: "bob" })({ age: 45, color: "blue" });
-    const r2 = defineType({ id: 2, slug: "chris" })({ age: 23, color: "red" });
-    const arr = [r1, r2];
-
-    const id = arrayToObject("id")(arr);
-    type Id = typeof id;
-    const slug = arrayToObject("slug")(arr);
-    type Slug = typeof slug;
-
-    expect(keys(id)).toContain("1");
-    expect(keys(id)).toContain("2");
-    expect(keys(slug)).toContain("bob");
-    expect(keys(slug)).toContain("chris");
-
-    type cases = [
-      // "id" and "slug" are always expressed as literals
-      Expect<Equal<Id["1"]["id"], 1>>,
-      Expect<Equal<Id["1"]["slug"], "bob">>,
-      Expect<Equal<Slug["bob"]["id"], 1>>,
-      Expect<Equal<Slug["bob"]["slug"], "bob">>,
-      // "age" and "color" are expressed as their widened types
-      Expect<Equal<Id["1"]["age"], number>>,
-      Expect<Equal<Id["1"]["color"], string>>
-    ];
-
-    const cases: cases = [true, true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/boolean-logic/Contains.test.ts

@@ -1,55 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { Contains, NarrowlyContains } from "src/types/boolean-logic/array";
-import { describe, it } from "vitest";
-
-describe("Contains<T,A>", () => {
-  it("happy-path", () => {
-    type T1 = [number, 32, 64, "foo"];
-    type T2 = [false, true];
-    type T3 = [42, 64, 128];
-    type T4 = ["foo", "bar"];
-
-    type cases = [
-      // "foo" extends string so true
-      Expect<Equal<Contains<string, T1>, true>>,
-      // "bar" does NOT extend "foo"
-      Expect<Equal<Contains<"bar", T1>, false>>,
-      // T4 has literal string but this will match the wide type string
-      Expect<Equal<Contains<string, T4>, true>>,
-      // T1 has both wide and narrow versions of "number"
-      Expect<Equal<Contains<number, T1>, true>>,
-      // T3 has narrow versions of "number"
-      Expect<Equal<Contains<number, T3>, true>>,
-      // boolean literals evaluate to wide type
-      Expect<Equal<Contains<boolean, T2>, true>>
-    ];
-    const cases: cases = [true, true, true, true, true, true];
-  });
-});
-
-describe("NarrowlyContains<T,A>", () => {
-  it("happy-path", () => {
-    type T1 = [number, 32, 64, "foo"];
-    type T2 = [false, true];
-    type T3 = [42, 64, 128];
-    type T4 = ["foo", "bar"];
-
-    type cases = [
-      // "foo" is not equal to string
-      Expect<Equal<NarrowlyContains<string, T1>, false>>,
-      // "foo" does equal "foo"
-      Expect<Equal<NarrowlyContains<"foo", T1>, true>>,
-      // T4 has literal string but this doesn't match with NarrowlyContains
-      Expect<Equal<NarrowlyContains<string, T4>, false>>,
-      // T1 has both wide and narrow versions of "number" but match is only on wide type
-      Expect<Equal<NarrowlyContains<number, T1>, true>>,
-      // T3 has matches on narrow number
-      Expect<Equal<NarrowlyContains<42, T3>, true>>,
-      // T3 identifies a non-match of narrow numbers
-      Expect<Equal<NarrowlyContains<442, T3>, false>>,
-      // boolean literals evaluate to wide type
-      Expect<Equal<NarrowlyContains<boolean, T2>, false>>
-    ];
-    const cases: cases = [true, true, true, true, true, true, true];
-  });
-});

package/tests/boolean-logic/HasParameters.ts

@@ -1,29 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { HasParameters } from "src/types";
-import { describe, it } from "vitest";
-
-// Note: type tests fail visible inspection but pass from Vitest
-// standpoint so always be sure to run `tsc --noEmit` over your test files to
-// gain validation that no new type vulnerabilities have cropped up.
-
-describe("HasParameters<T>", () => {
-  it("happy path", () => {
-    const fn1 = (foo: string) => `${foo}bar`;
-    const fn2 = (foo: string) => `${foo}bar` as const;
-    const fn3 = () => `hello world`;
-    const fn4 = () => `hello world` as const;
-    const fn5 = (r: string, g: string, b: string) => `${r},${g},${b}` as const;
-
-    type cases = [
-      // single
-      Expect<Equal<HasParameters<typeof fn1>, true>>,
-      Expect<Equal<HasParameters<typeof fn2>, true>>,
-      // none
-      Expect<Equal<HasParameters<typeof fn3>, false>>,
-      Expect<Equal<HasParameters<typeof fn4>, false>>,
-      // multiple
-      Expect<Equal<HasParameters<typeof fn5>, true>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-  });
-});

package/tests/boolean-logic/IsLiteral.spec.ts

@@ -1,65 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { Equal, Expect } from "@type-challenges/utils";
-import { IsBooleanLiteral, IsLiteral, IsOptionalLiteral } from "src/types";
-
-describe("IsLiteral<T> type utility", () => {
-  it("string values", () => {
-    const s = "hi" as string;
-    const sl = "hi" as const;
-
-    type cases = [
-      Expect<Equal<IsLiteral<typeof s>, false>>,
-      Expect<Equal<IsLiteral<typeof sl>, true>>
-    ];
-    const cases: cases = [true, true];
-    expect(typeof s).toBe("string");
-    expect(typeof sl).toBe("string");
-  });
-
-  it("numeric values", () => {
-    const v = 42 as number;
-    const vl = 42 as const;
-
-    type cases = [
-      Expect<Equal<IsLiteral<typeof v>, false>>,
-      Expect<Equal<IsLiteral<typeof vl>, true>>
-    ];
-    const cases: cases = [true, true];
-
-    expect(typeof v).toBe("number");
-    expect(typeof vl).toBe("number");
-  });
-
-  it("boolean values", () => {
-    const v = true as boolean;
-    const vl = false as const;
-
-    type cases = [
-      // wide
-      Expect<Equal<IsBooleanLiteral<typeof v>, false>>,
-      Expect<Equal<IsLiteral<typeof v>, false>>,
-      // literal
-      Expect<Equal<IsBooleanLiteral<typeof vl>, true>>,
-      Expect<Equal<IsLiteral<typeof vl>, true>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(typeof v).toBe("boolean");
-    expect(typeof vl).toBe("boolean");
-  });
-
-  it("union with undefined", () => {
-    const vb = true as true | undefined;
-    const vs = "foo" as "foo" | undefined;
-    const vn = 42 as 42 | undefined;
-
-    type cases = [
-      Expect<Equal<IsLiteral<Exclude<typeof vb, undefined>>, true>>, //
-      Expect<Equal<IsLiteral<Exclude<typeof vs, undefined>>, true>>, //
-      Expect<Equal<IsLiteral<Exclude<typeof vn, undefined>>, true>>, //
-      Expect<Equal<IsOptionalLiteral<typeof vb>, true>>, //
-      Expect<Equal<IsOptionalLiteral<typeof vs>, true>>, //
-      Expect<Equal<IsOptionalLiteral<typeof vn>, true>> //
-    ];
-    const cases: cases = [true, true, true, true, true, true];
-  });
-});

package/tests/boolean-logic/boolean.spec.ts

@@ -1,21 +0,0 @@
-import { describe, it, expect } from "vitest";
-// import type { Equal, Expect } from "@type-challenges/utils";
-import { and, filter } from "src/runtime";
-
-describe("boolean logic", () => {
-  it("AND operation", () => {
-    const a1 = and(
-      () => true,
-      () => false
-    );
-    const a2 = and(
-      () => true,
-      () => true
-    );
-    const md = and(filter({ endsWith: ".md" }), filter({ not: { startsWith: "_" } }));
-
-    expect(a1()).toBe(false);
-    expect(a2()).toBe(true);
-    expect(["foo.md", "bar.html", "_baz.md"].filter(md)).toEqual(["foo.md"]);
-  });
-});

package/tests/boolean-logic/filter.spec.ts

@@ -1,52 +0,0 @@
-import { filter } from "src/runtime";
-import { Equal, Expect } from "@type-challenges/utils";
-import { describe, it, expect } from "vitest";
-
-describe("filter() utility function", () => {
-  it("string filter built and gives proper types", () => {
-    const f = filter({ startsWith: "th" });
-    type P = Parameters<typeof f>;
-    type R = ReturnType<typeof f>;
-    const notPrivate = filter({ not: { startsWith: ["_", "."] } });
-
-    // runtime
-    expect(typeof f).toEqual("function");
-    expect(["one", "two", "three"].filter(f)).toEqual(["three"]);
-    expect(["foo.md", "bar.html", "_private.md", ".bobs-your-uncle.txt"].filter(notPrivate)) //
-      .toEqual(["foo.md", "bar.html"]);
-
-    // design time
-    type cases = [
-      Expect<Equal<P[0], string | undefined>>, //
-      Expect<Equal<R, boolean>>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("numeric filter built and gives proper types", () => {
-    const f = filter({ equals: 42 });
-    type P = Parameters<typeof f>;
-    type R = ReturnType<typeof f>;
-
-    // runtime
-    expect(typeof f).toEqual("function");
-    expect([1, 2, 3, 4, 5].filter(filter({ greaterThan: 3 }))) //
-      .toEqual([4, 5]);
-    expect([1, 2, 3, 4, 5].filter(filter({ not: { greaterThan: 3 } }))) //
-      .toEqual([1, 2, 3]);
-
-    // design time
-    type cases = [
-      Expect<Equal<P[0], number | undefined>>, //
-      Expect<Equal<R, boolean>>
-    ];
-    const cases: cases = [true, true];
-  });
-
-  it("string filter's startsWith", () => {
-    const f = filter({ startsWith: "." });
-    const remaining = ["foo", "bar", ".baz"].filter(f);
-
-    expect(remaining).toEqual([".baz"]);
-  });
-});

package/tests/constructor.spec.ts

@@ -1,42 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Expect, Equal } from "@type-challenges/utils";
-import { Constructor } from "../src/types/Constructor";
-
-class TestClass {
-  public foo: number;
-  public bar: string;
-
-  constructor(foo: number, bar: string) {
-    this.foo = foo;
-    this.bar = bar;
-  }
-}
-
-describe("Constructor<Ctor, Klass>", () => {
-  it("simple test", () => {
-    type KlassParams = ConstructorParameters<typeof TestClass>;
-    type KlassInstance = InstanceType<typeof TestClass>;
-    type Synthetic = Constructor<[foo: number, bar: string], TestClass>;
-    type SynReturn = InstanceType<Synthetic>;
-    const s: Synthetic = TestClass;
-
-    const myS = new s(1, "bar");
-
-    const inst = new TestClass(1, "bar");
-    type Instance = typeof inst;
-
-    type cases = [
-      // prep
-      Expect<Equal<Instance, { foo: number; bar: string }>>,
-      Expect<Equal<Instance, KlassInstance>>,
-      Expect<Equal<KlassParams, [foo: number, bar: string]>>,
-      //
-      Expect<Equal<SynReturn, TestClass>>
-    ];
-
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-    expect(myS).toBeInstanceOf(TestClass);
-  });
-});

package/tests/createFnWithProps.spec.ts

@@ -1,14 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createFnWithProps } from "../src/index";
-
-describe("createFnWithProps()", () => {
-  it("simple fn and prop are combined, type is retained", () => {
-    const fn = () => "hi";
-    const props = { foo: "bar" };
-    /** combo */
-    const combo = createFnWithProps(fn, props);
-
-    expect(combo.foo).toBe("bar");
-    expect(combo()).toBe("hi");
-  });
-});

package/tests/data/SimpleTable.hold

@@ -1,21 +0,0 @@
-import { IoModel } from "~/utility";
-
-export interface ISimpleTable<T extends {}, S extends Readonly<string>> {
-  name: S;
-  is: IoModel<T, S>["is"];
-  encode: IoModel<T, S>["encode"];
-  decode: IoModel<T, S>["decode"];
-  select: (...cols: Array<keyof T> | ["*"]) => string;
-}
-
-export const SimpleTable = <T extends {}, S extends Readonly<string>>(
-  model: IoModel<T, S>
-): ISimpleTable<T, S> => {
-  return {
-    name: model.name,
-    is: model.is,
-    encode: model.encode,
-    decode: model.decode,
-    select: (..._cols: Array<keyof T> | ["*"]) => `You did it`,
-  };
-};

package/tests/data/index.ts

@@ -1,12 +0,0 @@
-// #autoindex
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 06:09 PM ( GMT-7 )
-// hash-code: 683d9860
-
-
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/tests/data/playlist.hold

@@ -1,25 +0,0 @@
-import * as t from "io-ts";
-import * as D from "io-ts/Decoder";
-import { IoModel } from "~/utility";
-
-export const PlaylistRequired = {
-  /** name of the playlist */
-  name: t.string,
-  /** description of the playlist */
-  description: t.string,
-};
-export const PlaylistOptional = {
-  /** artists included in the playlist */
-  artists: t.array(t.string),
-};
-
-export const PlaylistIoTs = t.intersection([t.type(PlaylistRequired), t.partial(PlaylistOptional)]);
-export type IPlaylistIoTs = t.TypeOf<typeof PlaylistIoTs>;
-
-export const Playlist = IoModel("Playlist", PlaylistRequired, PlaylistOptional);
-
-export const Person = D.struct({
-  /** a person's name */
-  name: D.string,
-  age: D.number,
-});

package/tests/data/song.hold

@@ -1,23 +0,0 @@
-import * as t from "io-ts";
-import { IoModel } from "~/utility";
-
-export const SongMeta = t.partial({ year: t.number, genre: t.string });
-export const Song_RequiredProps = {
-  song: t.string,
-  artist: t.string,
-};
-export const Song_OptionalProps = {
-  /** the album which the song is featured in */
-  album: t.string,
-  /** the four digit year -- YYYY -- the song was released */
-  meta: SongMeta,
-};
-
-export const Song = IoModel("Song", Song_RequiredProps, Song_OptionalProps);
-export type ISong = t.TypeOf<typeof Song>;
-export const mySong: ISong = {
-  artist: "Billy Idol",
-  song: "Whiplash Smile",
-};
-
-export const Songs = t.array(Song);

package/tests/defineType-spec.ts

@@ -1,57 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { Expect, Equal } from "@type-challenges/utils";
-import { ExpectExtends } from "../src/types";
-import { defineType } from "../src/runtime";
-
-describe("inferredType() utility", () => {
-  it("only specify a wide type", () => {
-    const t = defineType({})({ foo: "", bar: 0 });
-
-    expect(t.foo).toBe("");
-    expect(t.bar).toBe(0);
-
-    // TODO: see if we can eliminate this difference
-    // between t and t2 though it is not impactful
-    const t2 = defineType()({ foo: "", bar: 0 });
-
-    expect(t2.foo).toBe("");
-    expect(t2.bar).toBe(0);
-
-    type cases = [
-      // when we provide {} as a literal type; we get the expected type
-      Expect<Equal<typeof t, { foo: string; bar: number }>>,
-      // for some odd reason, when we let the default value for literal
-      // we get something odd
-      Expect<
-        Equal<
-          typeof t2,
-          {
-            foo: string;
-            bar: number;
-            [x: string]: string | number | boolean | symbol | void | object | {} | null | undefined;
-          }
-        >
-      >,
-      // fortunately it does extend the intended type
-      Expect<ExpectExtends<typeof t2, { foo: string; bar: number }>>
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("only specify a literal type", () => {
-    const t = defineType({ foo: 1, bar: "hi" })();
-    type cases = [Expect<Equal<typeof t, { foo: 1; bar: "hi" }>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("specify both wide and literal merged type", () => {
-    const t = defineType({ bar: 1 })({ foo: "" });
-
-    type cases = [Expect<Equal<typeof t, { foo: string; bar: 1 }>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/dictionary/DictChangeValue.test.ts

@@ -1,30 +0,0 @@
-import { describe, it } from "vitest";
-import type { Expect, Equal } from "@type-challenges/utils";
-import { DictChangeValue } from "../../src/types/dictionary/DictChangeValue";
-import { SimplifyObject } from "../../src/types/SimplifyObject";
-
-const test_obj = {
-  foo: "hello world",
-  bar: 42,
-  baz: () => "that's all folks",
-} as const;
-type TestObj = typeof test_obj;
-
-describe("DictChangeValue", () => {
-  it("convert all KVs to a single value type", () => {
-    type T = DictChangeValue<TestObj, number>;
-
-    type cases = [Expect<Equal<T, { foo: number; bar: number; baz: number }>>];
-    const cases: cases = [true];
-  });
-
-  it("convert functions values to boolean", () => {
-    type F = DictChangeValue<TestObj, boolean, Function>;
-    type S = DictChangeValue<TestObj, string, string>;
-    type N = DictChangeValue<TestObj, number, number>;
-    type T = SimplifyObject<F & S & N>;
-
-    type cases = [Expect<Equal<T, { foo: string; bar: number; baz: boolean }>>];
-    const cases: cases = [true];
-  });
-});

package/tests/dictionary/DictPartialApplication.test.ts

@@ -1,43 +0,0 @@
-import { describe, it } from "vitest";
-
-import type { DictPartialApplication } from "src/types";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-describe("DictUnwrapValues<T>", () => {
-  it("happy path", () => {
-    const api = {
-      hi: (name: string) => `hi ${name}`,
-      bye: (name: string) => `bye ${name}`,
-    };
-
-    type Api = typeof api;
-    type T = DictPartialApplication<Api>;
-    type Expected = { hi: string; bye: string };
-
-    type cases = [Expect<Equal<T, Expected>>];
-
-    const cases: cases = [true];
-  });
-
-  it("object which has non-function based props", () => {
-    const api = {
-      theAnswer: 42,
-      hi: (name: string) => `hi ${name}`,
-      bye: (name: string) => `bye ${name}`,
-    };
-
-    type Api = typeof api;
-    type T1 = DictPartialApplication<Api>;
-    type T2 = DictPartialApplication<Api, true>;
-    type T3 = DictPartialApplication<Api, false>;
-    type Expected = { hi: string; bye: string };
-    type Expected3 = { theAnswer: number; hi: string; bye: string };
-
-    type cases = [
-      Expect<Equal<T1, Expected>>,
-      Expect<Equal<T2, Expected>>,
-      Expect<Equal<T3, Expected3>>
-    ];
-    const cases: cases = [true, true, true];
-  });
-});