21 replies

Need help with typescript stuff

I am trying to implement the

Maybe

Maybe

monad in typescript. It's like the

Option

Option

type in Rust.

Here's what I have so far:

const None = Symbol("None");

export class Maybe<T> {
  constructor(private value: T | typeof None) {}

  static some<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return new Maybe<T>(value);
  }

  static none<T>(): Maybe<T> {
    return new Maybe<T>(None);
  }

  static from<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return Maybe.some(value);
  }

  public match<U>({ some, none }: { some: (value: T) => U; none: () => U }): U {
    if (this.value === None) return none();

    return some(this.value);
  }

  public map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return Maybe.some(fn(this.value));
  }

  public flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return fn(this.value);
  }

  public getOrElse<U>(value: U): T | U {
    if (this.value === None) return value;

    return this.value;
  }
}

const None = Symbol("None");

export class Maybe<T> {
  constructor(private value: T | typeof None) {}

  static some<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return new Maybe<T>(value);
  }

  static none<T>(): Maybe<T> {
    return new Maybe<T>(None);
  }

  static from<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return Maybe.some(value);
  }

  public match<U>({ some, none }: { some: (value: T) => U; none: () => U }): U {
    if (this.value === None) return none();

    return some(this.value);
  }

  public map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return Maybe.some(fn(this.value));
  }

  public flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return fn(this.value);
  }

  public getOrElse<U>(value: U): T | U {
    if (this.value === None) return value;

    return this.value;
  }
}

Here the

from

from

method is used to take in a value and convert it to a

Maybe<value>

Maybe<value>

. For example:

const a = Maybe.from(9);
//    ^? const a: Maybe<number>

const b = Maybe.from("hi");
//    ^? const b: Maybe<string>

const a = Maybe.from(9);
//    ^? const a: Maybe<number>

const b = Maybe.from("hi");
//    ^? const b: Maybe<string>

But there's a problem, when I pass a value that could either be some type (like number, string, etc) or null or undefined, it returns

Maybe<value | undefined>

Maybe<value | undefined>

. The Maybe monad handles this by using

none

none

so there's no need to have

Maybe<value | undefined>

Maybe<value | undefined>

, it just needs to be

Maybe<value>

Maybe<value>

. For example:

const z = Maybe.from([1, 2, 3].pop()); // z is Maybe<number | undefined> but I want Maybe<number>

const z = Maybe.from([1, 2, 3].pop()); // z is Maybe<number | undefined> but I want Maybe<number>

How do I modify my code in order to implement this behaviour?

Playground link: https://www.typescriptlang.org/play?#code/MYewdgzgLgBAcuApjAvDAygTwLYCMQA2AFAEQJiIkCUA3AFB2IAeADiAE6zAECGEEMALI9MuRAB4AKgD4YAbzowYoSFHYBXYFA5EW7AJYA3HlGTGC6xAC4YkmAB8YUTC0QgAZvCRV5AXwZK0Cb6wDAQINgSMkTmljaSVDbColGyCkpK+p4xPBbIKAUwYOoEBA6OsfmF6mAAJoju+hS1PuyIUOrsYEIiYgB0YEhS0kS0ARltHV1FiADuPSnDOXljSv6KYVDBoYMUS4kLYsPyG0qTnd0U88lH0eSIqzDrgVtQITDu7BFLlfEHN6kThkYFkYMtLKhCsVSuUYJVIWgavVGs1Wu0LodEAMhtExqcYOdpgC+uFIuCHvQ1uMWOpcAR3tgTMAABbiACqIzkYQiiAANEUkE8bFzSdYwb9bD4ULI2TQBRQbKNUDKngc2UCMqCiFBmfoIH14QU0Pc0VNLkhRvR8YTuqLtbr9ZVHs8YDS6QyeCx2SN3GBFRKEsqYGz-r0JByNZlsjq9QbchCjV4KKaMcTduGRnjgTbMSSeURffbY07ndTafTQu5eFBhF6OQW-eL42LA9LMd7Q4sI+lNdGHXG8gikw8CeiiWHsXt61mJmPuoWY47m6WNm6KzAAObtADy7AAogQIBnyTYQ-EHMHIyC+8Xm0OTaOzXDm1bs3OnP3KpSnnR1ipoDATCoLmnwREQADaACM-IAEz8gAzAAun0bAsKMYwAPQYcCAB6AD8QA

TS Playground - An online editor for exploring TypeScript and JavaS...

The Playground lets you write TypeScript or JavaScript online in a safe and sharable way.

TTC

Theo's Typesafe Cult•4y ago•

21 replies

nexxel

Need help with typescript stuff

I am trying to implement the

Maybe

Maybe

monad in typescript. It's like the

Option

Option

type in Rust.

Here's what I have so far:

const None = Symbol("None");

export class Maybe<T> {
  constructor(private value: T | typeof None) {}

  static some<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return new Maybe<T>(value);
  }

  static none<T>(): Maybe<T> {
    return new Maybe<T>(None);
  }

  static from<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return Maybe.some(value);
  }

  public match<U>({ some, none }: { some: (value: T) => U; none: () => U }): U {
    if (this.value === None) return none();

    return some(this.value);
  }

  public map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return Maybe.some(fn(this.value));
  }

  public flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return fn(this.value);
  }

  public getOrElse<U>(value: U): T | U {
    if (this.value === None) return value;

    return this.value;
  }
}

const None = Symbol("None");

export class Maybe<T> {
  constructor(private value: T | typeof None) {}

  static some<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return new Maybe<T>(value);
  }

  static none<T>(): Maybe<T> {
    return new Maybe<T>(None);
  }

  static from<T>(value: T): Maybe<T> {
    if (value === null || value === undefined) return Maybe.none<T>();

    return Maybe.some(value);
  }

  public match<U>({ some, none }: { some: (value: T) => U; none: () => U }): U {
    if (this.value === None) return none();

    return some(this.value);
  }

  public map<U>(fn: (value: T) => U): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return Maybe.some(fn(this.value));
  }

  public flatMap<U>(fn: (value: T) => Maybe<U>): Maybe<U> {
    if (this.value === None) return Maybe.none<U>();

    return fn(this.value);
  }

  public getOrElse<U>(value: U): T | U {
    if (this.value === None) return value;

    return this.value;
  }
}

Here the

from

from

method is used to take in a value and convert it to a

Maybe<value>

Maybe<value>

. For example:

const a = Maybe.from(9);
//    ^? const a: Maybe<number>

const b = Maybe.from("hi");
//    ^? const b: Maybe<string>

const a = Maybe.from(9);
//    ^? const a: Maybe<number>

const b = Maybe.from("hi");
//    ^? const b: Maybe<string>

But there's a problem, when I pass a value that could either be some type (like number, string, etc) or null or undefined, it returns

Maybe<value | undefined>

Maybe<value | undefined>

. The Maybe monad handles this by using

none

none

so there's no need to have

Maybe<value | undefined>

Maybe<value | undefined>

, it just needs to be

Maybe<value>

Maybe<value>

. For example:

const z = Maybe.from([1, 2, 3].pop()); // z is Maybe<number | undefined> but I want Maybe<number>

const z = Maybe.from([1, 2, 3].pop()); // z is Maybe<number | undefined> but I want Maybe<number>

TS Playground - An online editor for exploring TypeScript and JavaS...

The Playground lets you write TypeScript or JavaScript online in a safe and sharable way.

Need help with typescript stuff

Need help with typescript stuff

Similar Threads

Similar Threads

Similar Threads