/**
 * represents a simple "present or absent" type.
 *
 * This is very similar to existing implementations, e.g. in fp-ts
 * and differs mostly in that the types are a bit more relaxed.
 *
 * @module
 */

import { identity } from "./Function.js";

export type Option<T> = Readonly<
  { __tag: "some"; value: T } | { __tag: "none" }
>;

export const some = <T>(value: T): Option<T> => ({ __tag: "some", value });
export const none: Option<never> = { __tag: "none" };

export const fromNullable = <T>(value: T | undefined | null): Option<T> =>
  value == null ? none : some(value);

export const map =
  <T, U>(fn: (value: T) => U) =>
  (option: Option<T>): Option<U> =>
    option.__tag === "none" ? option : some(fn(option.value));

export const flatMap =
  <T, U>(fn: (value: T) => Option<U>) =>
  (option: Option<T>): Option<U> =>
    option.__tag === "none" ? option : fn(option.value);

export const match =
  <T, R>(onNone: () => R, onSome: (value: T) => R) =>
  (option: Option<T>): R =>
    option.__tag === "none" ? onNone() : onSome(option.value);

export const getOrElse = <T, F>(fn: () => F) => match<T, T | F>(fn, identity);

export const toUndefined = <T>(option: Option<T>): T | undefined =>
  getOrElse<T, undefined>(() => undefined)(option);

export const alt =
  <T>(second: Option<T>) =>
  (first: Option<T>) =>
    first.__tag === "some" ? first : second;

/**
 * attempt to evaluate a function, returns none if evaluation throws
 */
export const attempt = <T>(fn: () => T): Option<T> => {
  try {
    return some(fn());
  } catch {
    return none;
  }
};