JSPM

  • ESM via JSPM
  • ES Module Entrypoint
  • Export Map
  • Keywords
  • License
  • Repository URL
  • TypeScript Types
  • README
  • Created
  • Published
  • Downloads 44
  • Score
    100M100P100Q60238F
  • License MIT

Rust like enum, Result and Option for javascript

Package Exports

  • rusted

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (rusted) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

npm version Coverage Status Build Status

rusted

Rust-like enum, Result, Option, impl and match for javascript.

Feature

  • enum
    • type checking
  • struct
    • type checking
    • mutable property
  • impl
    • static method
  • trait
  • iter
  • type alias
  • panic (not a macro)
  • match
  • Result
  • Option

Install

npm install rusted

Example

These examples require es6 transpiler.

enum (and impl (and match))

import {Enum,impl,match} from 'rusted';

/*
enum Message {
    Quit,
    ChangeColor(i32,i32,i32),
    Move {x:i32, y:i32},
    Write(String)
}
*/

let Message=Enum({
    Quit:null,
    ChangeColor:[0,0,0],
    Move:{x:0,y:0},
    Write:''
});

// let x: Message = Message::Move { x: 3, y: 4 };
let x=Message.Move({x:3,y:4});

// let y: Message = Message::Quit;
let y=Message.Quit;

impl(Message,{
    print(self){
        console.log(match(self,{
            Quit:()=>'Quit!',
            ChangeColor:[r,g,b]=>`Changed to ${r},${g},${b}`,
            Move:{x,y}=>`Moved to (${x},${y})`,
            Write:x=>x
        }));
    }
});

x.print(); // > Moved to (3,4)
y.print(); // > Quit!

struct (and impl)

struct checks type of property when instantiate.

  • 'any'
    • do not check type
  • 'number','string','object'... (String)
    • compared to typeof value_of_prop
  • Object,Array,Number... (Constructor)
    • compared to value_of_prop.constructor
import {struct,impl} from 'rusted';

let Circle=struct({
    x:'number',
    y:'number',
    radius:'number'
});

impl(Circle,{
    area(self){
        return Math.PI*(self.radius*self.radius);
    }
});

let c=Circle({
    x:0,y:0,
    radius:2
});

console.log(c.area()); // > 12.56...

Option

import {Some,None,match} from 'rusted';

let divide=(numerator,denominator)=>{
    return denominator==0
            ? None
            : Some(numerator/denominator);
};

let result = divide(2.0, 3.0);

match(result,{
    Some:x=>console.log(`Result: ${x}`),
    None:()=>console.log('Cannot divide by 0')
});
// > Result: 0.666...

Result

import {Ok,Err,match} from 'rusted';

function Foo(x){
    if(x>5){
        return Ok(x);
    }else{
        return Err('Less than 5 !');
    }
}

console.log(match(Foo(3),{
    Ok:x=>x,
    Err:e=>e
}));
// > Less than 5 !

console.log(Foo(10).unwrap());
// > 10
console.log(Foo(3).unwrap());
// throws error

(es5 version.)

var rusted=require('rusted'),
    Ok=rusted.Ok,
    Err=rusted.Err,
    match=rusted.match;

function Foo(x){
    if(x>5){
        return Ok(x);
    }else{
        return Err('Less than 5 !');
    }
}

console.log(match(Foo(3),{
    Ok:function(x){
        return x;
    },
    Err:function(e){
        return e;
    }
}));

console.log(Foo(10).unwrap());
console.log(Foo(3).unwrap());

License

MIT