@schrosis/rus-ts v0.0.2

@schrosis/rus-ts

🦀 < Something like Rust with excellent type inference.

Install

npm install @schrosis/rus-ts

or

yarn add @schrosis/rus-ts

Feature

• Rust like Option type.
• Rust like Result type. (Coming soon)
• Zero dependency.
• No panic!

Usage

Option

Type Option represents an optional value: every Option is either Some and contains a value, or None, and does not. Option types are very common in Rust code, as they have a number of uses:

• Initial values
• Return value for otherwise reporting simple errors, where None is returned on error
• Optional struct fields
• Optional function arguments
• Swapping things out of difficult situations

Options are paired with pattern matching by if to query the presence of a value and take action, always accounting for the None case.

const divide = (numerator: number, denominator: number): Option<number> => {
  if (denominator === 0) {
    return None;
  } else {
    return Some(numerator / denominator);
  }
};

// The return value of the function is an option
let result = divide(2.0, 3.0);

// Pattern match to retrieve the value
if (result.isSome()) {
  // The division was valid
  console.log(`Result: ${result.value}`);
} else {
  console.log('Cannot divide by 0');
}

Method overview

Option implements several methods in Rust Option.

Querying the variant

The isSome and isNone methods return true if the Option is Some or None, respectively.

Extracting the contained value

If Option is type inferred as Some, it can be accessed by this.value.

*TypeScript does not have the concept of panic, so references that result in a panic are not allowed.

Transforming contained values

These methods transform Option to Result:

• okOr transforms Some(v) to Ok(v), and None to Err(err) using the provided default err value
• okOrElse transforms Some(v) to Ok(v), and None to a value of Err using the provided function
• transpose transposes an Option of a Result into a Result of an Option

(Coming soon.)

These methods transform the Some variant:

• filter calls the provided predicate function on the contained value t if the Option is Some(t), and returns Some(t) if the function returns true; otherwise, returns None
• flatten removes one level of nesting from an Option<Option<T>>
• map transforms Option<T> to Option<U> by applying the provided function to the contained value of Some and leaving None values unchanged

These methods transform Option<T> to a value of a possibly different type U:

• mapOr applies the provided function to the contained value of Some, or returns the provided default value if the Option is None
• mapOrElse applies the provided function to the contained value of Some, or returns the result of evaluating the provided fallback function if the Option is None

These methods combine the Some variants of two Option values:

• zip returns Some([s, o]) if self is Some(s) and the provided Option value is Some(o); otherwise, returns None

Boolean operators

These methods treat the Option as a boolean value, where Some acts like true and None acts like false. There are two categories of these methods: ones that take an Option as input, and ones that take a function as input (to be lazily evaluated).

The and, or, and xor methods take another Option as input, and produce an Option as output. Only the and method can produce an Option<U> value having a different inner type U than Option<T>.

The andThen and orElse methods take a function as input, and only evaluate the function when they need to produce a new value. Only the andThen method can produce an Option<U> value having a different inner type U than Option<T>.

Methods not in Rust

In TypeScript, the types T|undefined and T|null are usually used. There are methods to generate Option from these types.

For more

🦀 < See the module level documentation for more.