GeezerVison

declare class Point {
  constructor(x: number, y: number)
  readonly x: number
  readonly y: number
}

declare class Bag<T> {
  constructor(...args: T[])
  contains(value: T): boolean
  static foo: string
}

function asFunction<A extends any[], B>(cf: new (...args: A) => B) {
  return (...args: A) => new cf(...args)
}

const newPoint = asFunction(Point) // (x: number, y: number) => Point
const newBag = asFunction(Bag) // <T>(...args: T[]) => Bag<T>
const p1 = new Point(10, 20) // Point
const p2 = newPoint(10, 20) // Point
const bag1 = new Bag(1, 2, 3) // Bag<number>
const bag2 = newBag('a', 'b', 'c') // Bag<string>

declare class Component<P> {
  props: P
  constructor(props: P)
}

interface ComponentClass<P> {
  new (props: P): Component<P>
  thisWillBreakGenericInference?: boolean // <--- this is breaking the type inference
}

declare function myHoc<P>(C: ComponentClass<P>): ComponentClass<P>

type GenericProps<T> = { foo: number; stuff: T }

declare class GenericComponent<T> extends Component<GenericProps<T>> {}

// Should be:
// const GenericComponent2: new <T>(props: GenericProps<T>) => Component<GenericProps<T>>
// Actually: 
// const GenericComponent2: ComponentClass<GenericProps<unknown>>

const GenericComponent2 = myHoc(GenericComponent)

function compose<T, U, V>(
    f: (x: T) => U, g: (y: U) => V): (x: T) => V {
    
    return x => g(f(x))
}

-- Haskell
(.) :: (b -> c) -> (a -> b) -> a -> c

// Sanctuary.js
compose :: Semigroupoid s => s b c -> s a b -> s a c

// fp-ts
export interface Semigroupoid<F> {
  readonly URI: F
  readonly compose: <E, A, B>(ab: HKT2<F, A, B>, la: HKT2<F, E, A>) => HKT2<F, E, B>
}

// Ramda
(b -> c) -> (a -> b) -> a -> c

// Crocks
composeB :: (b -> c) -> (a -> b) -> a -> c

type fn1<I, O> = (i: I) => O
type compose = <T extends any, U, V>(f: fn1<U, V>) => (g: fn1<T, U>) => fn1<T, V>
const compose: compose = f => g => a => f (g (a))