evaporei

class Container<T> implements Monad<T> {
    private value: T

    constructor(value: T) {
        this.value = value
    }

    bind<U>(f: (a: T) => Monad<U>): Monad<U> {
        return f(this.value)
    }

evaporei

interface Monad<A> {
    bind<B>(f: (a: A) => Monad<B>): Monad<B>
    return(a: A): Monad<A>
}

evaporei

console.log('mapped list:', [1, 2, 3].map(x => x * 2)) // [2, 4, 6]

evaporei

class Container<T> implements Functor<T> {
    private value: T

    constructor(value: T) {
        this.value = value
    }

    fmap<U>(f: (a: T) => U): Functor<U> {
        return new Container(f(this.value))
    }

evaporei

class Container<T> {
    private value: T
    
    constructor(value: T) {
        this.value = value
    }
}

console.log('simple container:', new Container(5)) // Container { value: 5 }

evaporei

interface Functor<A> {
    fmap<B>(f: (a: A) => B): Functor<B>
}

evaporei

String.prototype.mappend = function (x: String): String {
    return this + x
}

String.prototype.mempty = function (): String {
    return ""
}

console.log(
    'String mappend:',

evaporei

Number.prototype.mappend = function (x: Number): Number {
    return this * x
}

Number.prototype.mempty = function (): Number {
    return 1
}

console.log('mappend:', Number(5).mappend(4)) // 20
console.log('mempty:', Number().mempty()) // 1

evaporei

Number.prototype.mappend = function (x: Number): Number {
    return this + x
}

Number.prototype.mempty = function (): Number {
    return 0
}

console.log('mappend:', Number(5).mappend(4)) // 9
console.log('mempty:', Number().mempty()) // 0

evaporei

interface Monoid<M> {
    mappend(x: M): M    // operação binária
    mempty(): M         // elemento neutro
}