Modeling the Maybe monad in TypeScript

maybe.ts

/** 
 * Tag
 * These are used to create the Tagged Union
 **/

const enum Tag {
  None = "None",
  Some = "Some"
}

/** 
 * MEMBERS
 * None and Some are Maybe Members
 **/

interface None { tag: Tag.None }
interface Some<A> { tag: Tag.Some, data: A }

/** 
 * MAYBE
 * Maybe is the Union of None and Some.
 * It is parameterized by a generic type.
 **/

type Maybe<A> = None | Some<A>

/** 
 * Maybe Constructors
 * None is constant while Some is parameterized (function)
 **/

const None: None = { tag: Tag.None }
const Some = <A>(x: A): Some<A> => ({ tag: Tag.Some, data: x })


/** 
 * USEAGE EXAMPLES
 * Below are some examples of how to use Maybe
 **/

const either = <A>(x: Maybe<A>, y: A): A => {
  switch (x.tag) {
    case Tag.Some:
      return x.data
    case Tag.None:
      return y
    default:
      return assertNever(x, y)
  }
}

const assertNever = <A>(x: never, y: A) => y

const thing = either(Some("hi"), "bye")

interface User {
  name: string
} 

const head = <A>(xs: A[]): Maybe<A> => xs[0] === undefined ? None : Some(xs[0])

const users: User[] = []

const firstUser = head(users)