Rust-like-enum

The Typescript implemention for Rust enums

• Easy use
• Full type support
• Scalable

Install

npm install rl-enum

Usage

Enum Define

// Rust
enum ExampleEnum {
  Foo,
  Bar(i32)
}

// Typescript
const ExampleEnum = RlEnum<{
  Foo: null,
  Bar: number,
}>()

Enum use

// Rust
let foo = ExampleEnum::Foo;
let bar = ExampleEnum::Bar(1);

// Typescript
const foo = ExampleEnum.Foo();
const bar = ExampleEnum.Bar(1);

if let

// Rust
if let ExampleEnum::Bar(v) = bar {
    println!("{}", v);
}

// Typescript
// get value. if is bar, return number，otherwise return null.
const v: number | null = bar.Bar();

// or use isBar() to check whether is bar.
if (bar.isBar()) {
  console.log(bar.Bar()!);
}

// check enum type and value. If the value is not 1, also return false.
if (bar.isBar(1)) {
  console.log(bar.Bar()!);
}

match

// rust
let bar = ExampleEnum::Bar(1);
match bar { 
    ExampleEnum::Bar(v) => println!("{}", v),
    _ => {}
}

// Typescript
const bar = ExampleEnum.Bar(1);
bar.match({
  Bar: (v) => console.log(v),
  _: () => {},
})

impl methods

// Rust
impl ExampleEnum {
    fn unwrap(&self) -> i32 {
        if let ExampleEnum::Bar(v) = self {
            *v
        } else {
            panic!()
        }
    }
}

let v = ExampleEnum::Bar(1).unwrap();

// Typescript
ExampleEnum.impl((v) => ({
  unwrap() {
    if (v.isBar()) {
      return v.Bar();
    }
    throw new Error();
  }
}));

const v = ExampleEnum.Bar(1).unwrap();

Prelude Enums

Rust std enums (Result and Option) has been implemented.

Result

methods:

• unwrap
• unwrap_or
• unwrap_or_else

const ok = Ok(1);
const v: number = ok.unwrap();

const err = Err(new Error());
const v: number = err.unwrapOr(1);

Option

methods:

• ok_or
• unwrap
• unwrap_or
• unwrap_or_else

const result = Some(1).okOr(new Error());

const v: number = Some(1).unwrap();

const v: number = Some(1).unwrapOr(2);

const v: number = Some(1).unwrapOrElse(() => 2);

Promise

An implementation of converting async promise into sync result.

before

try {
  const res = await new Promise(...);
  console.log(res);
} catch(e) {
  console.error(e);
}

The problem is that if any code after await encounters a panic, it will also end up in the catch block.

after

const result = await new Promise(...).result();
if (result.isOk()) {
  console.log(result.Ok())
} else {
  console.error(result.Err())
}