higher kinded types implementation

hkt.ts

interface HKT<K, T>{
}
interface Monad<M> {
    bind: <A, B>(m: HKT<M, A>, k: (a: A) => HKT<M, B>) => HKT<M, B>
    return: <A>(a: A) => HKT<M, A>
    // ret$: <A>(m: (a: A) => HKT<M, A>) => HKT<M, A>

}

class Maybe implements Monad<Maybe> {
    bind<A, B>(m: HKT<Maybe, A>, k: (a: A) => HKT<Maybe, B>): HKT<Maybe, B>{
        if (m instanceof Some){
            let mm = m as Some<A>
            return k(mm.content)
        }
        return new None<A>()
    }
    return<A>(a: A): HKT<Maybe, A>{
        return new Some(a)
    }
}

class Some<A> implements HKT<Maybe, A>{
    content: A
    constructor(a: A){
        this.content = a 
    }
}

class None<A> implements HKT<Maybe, A>{
    constructor(){}
}
let m = new Some(1) as HKT<Maybe, number>
function bind<M>(m: Monad<M>): <A>(ma: HKT<M, A>) => <B>(k: (a: A) => HKT<M, B>) => HKT<M, B> {
    return ma => k => m.bind(m, k) 
}
let f = bind(new Maybe())
let k: (_:number) => HKT<Maybe, number> = (x: number) => new Some(x + 1) as HKT<Maybe, number>
let f2 = f(m)(k)