maybe.ts

import { curry } from 'ramda'

enum MaybeType {
  Just = 'maybe-type__just',
  Nothing = 'maybe-type__nothing',
}

interface Just<T> extends Readonly<{
  type: typeof MaybeType.Just
  value: T
}> {}

interface Nothing extends Readonly <{
  type: typeof MaybeType.Nothing
}> {}

type Maybe<T>
  = Just<T>
  | Nothing

const Nothing = (): Nothing => ({
  type: MaybeType.Nothing,
})

const Just = <T> (value: T): Just<T> => ({
  type: MaybeType.Just,
  value,
})

function maybeMap<A, B> (f: (val: A) => B, m: Maybe<A>): Maybe<B> {
  switch (m.type) {
    case MaybeType.Nothing:
      return Nothing()
    case MaybeType.Just:
      return Just(f(m.value))
  }
}

function maybeAndThen<A, B> (f: (val: A) => Maybe<B>, m: Maybe<A>): Maybe<B> {
  switch (m.type) {
    case MaybeType.Nothing:
      return Nothing()
    case MaybeType.Just:
      return f(m.value)
  }
}

function maybeOf<T> (value: T): Maybe<T> {
  return value === undefined || value === null
    ? Nothing()
    : Just(value)
}

function maybeWithDefault<T> (defaultVal: T, m: Maybe<T>): T {
  switch (m.type) {
    case MaybeType.Nothing:
      return defaultVal
    case MaybeType.Just:
      return m.value
  }
}

const Maybe = {
  andThen: curry(maybeAndThen),
  map: curry(maybeMap),
  of: maybeOf,
  withDefault: curry(maybeWithDefault),
}

Nice