curry

curry.ts

type l<F extends number> = F extends number ? F : never;

type one = l<1>;
type two = l<2>;
type three = l<3>;

type pt1 = [string, number, boolean];
const f1 = (...a: pt1) => true;

const fn00 = (name: string, age: number, single: boolean) => true;
type fn00type = typeof fn00;
type t00 = Parameters<typeof fn00>;

type R<F extends (...args: any[]) => any> = F extends (...args: any[]) => infer A
    ? A : never;

type Params<F extends (...args: any[]) => any> = F extends (...args: infer A) => any
    ? A : never;

const fn01 = (a: string, b: number) => false;
type fn01r = R<typeof fn01>;
type fn01p = Params<typeof fn01>;

type Head<F extends any[]> = F extends [infer T, ...any[]] ? T : never; 

type h1 = Head<[boolean, number, string]>;

type Tail<F extends any[]> =
    ((...t: F) => any) extends ((_: any, ...r: infer R) => any)
    ? R : never; 

type t1 = Tail<[boolean, number, string]>;

type Tail2<F extends [any, ...any[]]> =
    F extends [any, ...(infer R)[]]
    ? R : never; 

type t2 = Tail2<[boolean, number, string]>;

type HasTail<T extends [...any[]]> = T extends [] ? false : T extends [any] ? false : true;
type ht1 = HasTail<[]>;
type ht2 = HasTail<[string]>;
type ht3 = HasTail<[string, number]>;


type Swap<T> = T extends [infer T1, infer T2] ? [T2, T1] : never;
type s1 = Swap<[string, number]>;

// type RoundShift<T extends [any, ...any[]]> = Params<(h: Head<T>, ...t:Tail<T>) => any>;
// type r1 = RoundShift<[boolean, number, string]>;

// type Insert<T1 extends any, T2 extends [...any[]]> = Params<(...[T1, ...T2]) => any>

// type Append<T1 extends [...any[]], T2 extends [...any[]]> = HasTail<T1> extends false
//     ? [T1, ...T2]; 


type Insert<T1, T2 extends any[]> =
    ((head: T1, ...r: T2) => any) extends ((...args: infer U) => any)
    ? U : never;


type i1 = Insert<number, [string, boolean]>;

type v0 = [string, number, boolean][0];
type v1 = [string, number, boolean][1];
type v2 = [string, number, boolean][2];
type vlength = [string, number, boolean]['length']; 

type abc = { a: string; b: number; c: boolean };
type abc1 = abc['a'];
type abc2 = abc['b'];
type abc3 = abc['c'];
type abckeys = keyof abc;

type Last<T extends any[]> = {
    l: Last<Tail<T>>,
    h: Head<T>
}[HasTail<T> extends true ? 'l' : 'h'];

type l1 = Last<[string, number, boolean]>;

type Concat<T1 extends any[], T2 extends any[]> = [...T1, ...T2];

type Len<T extends any[]> = T['length'];
type _TupleNIterate<N extends number, T, A extends any[]> = {
    a: A,
    n: _TupleNIterate<N, T, Insert<T, A>>
}[Len<A> extends N ? 'a' : 'n'];
type TupleN<N extends number, T> = _TupleNIterate<N, T, []>;
type Vector<N extends number> = TupleN<N, number>;
type Matrix<N extends number, M extends number> = TupleN<N, Vector<M>>;
type MatrixMul<N extends number, M extends number> = [];


type vector3 = Vector<3>;
type matrix3x5 = Matrix<3, 5>;