Lazy.ts

Lazy.ts

type Lazy<A> = () => A

const Lazy = {
    map<A, B>(l: Lazy<A>, fn: (a: A) => B): Lazy<B> {
        return lazy(() => fn(l()))
    }
}

function lazy<A>(fn: () => A): Lazy<A> {
    let memoized: { value: A } | false = false
    return (): A => {
        if (memoized === false) {
            const value = fn()
            memoized = { value }
            return value
        } else {
            return memoized.value
        }
    }
}



interface ILazyList<A> {
    map<B>(fn: (a: A) => B): ILazyList<B>
}

class LazyCons<A> implements ILazyList<A> {
    constructor(public readonly head: Lazy<A>, public readonly tail: Lazy<ILazyList<A>>) { }

    map<B>(fn: (a: A) => B): ILazyList<B> {
        return new LazyCons<B>(
            Lazy.map(this.head, fn),
            Lazy.map(this.tail, nonLazyTail => nonLazyTail.map(fn))
        )
    }
}

class LazyNil<A> implements ILazyList<A> {
    map<B>(fn: (a: A) => B): ILazyList<B> {
        return new LazyNil<B>()
    }
}