Maybe.ts

export enum MaybeType {
  Just = 'Just',
  Nothing = 'Nothing',
}

interface IMaybe {
  type: MaybeType;
}

interface IJust<T> extends IMaybe {
  type: MaybeType.Just;
  data: T;
}

interface INothing<T> extends IMaybe {
  type: MaybeType.Nothing;
}

interface ICases<T, U> {
  just: (t: T) => U;
  nothing: () => U;
}

export type Maybe<T> = IJust<T> | INothing<T>;

const Maybe = {
  chain: <T, T1>(chainF: (data: T) => Maybe<T1>, maybe: Maybe<T>) =>
    maybe.type === MaybeType.Just ? chainF(maybe.data) : maybe,

  map: <T, T1>(mapF: (data: T) => T1, maybe: Maybe<T>) =>
    maybe.type === MaybeType.Just ? mapF(maybe.data) : maybe,

  withDefault: <T>(defaultValue: T, maybe: Maybe<T>) =>
    maybe.type === MaybeType.Just ? maybe.data : defaultValue,

  nothing: <T>(): Maybe<T> => ({
    type: MaybeType.Nothing,
  }),

  just: <T>(data: T): Maybe<T> => ({
    data,
    type: MaybeType.Just,
  }),

  from: <T>(value: T | undefined | null): Maybe<T> =>
    value === undefined || value === null
      ? Maybe.nothing<T>()
      : Maybe.just(value),

  caseOf: <T, U>(maybe: Maybe<T>, cases: ICases<T, U>): U =>
    maybe.type === MaybeType.Just ? cases.just(maybe.data) : cases.nothing(),
};

export default Maybe;