import {Enum} from 'rusted';
 
//enum Message {
//	Quit,
//	ChangeColor(i32,i32,i32),
//	Move {x:i32, y:i32},
//	Write(String)
//}
let Message=Enum({
    Quit:null, // no data
    ChangeColor:Array, // accepts if data.constructor==Array
    Move:'object', // accepts if typeof data=='object'
    Write:'string' // accepts if typeof data=='string'
});
 
// with data
let x=Message.Move({x:3,y:4}); // let x: Message = Message::Move { x: 3, y: 4 };
// without data
let y=Message.Quit; // let y: Message = Message::Quit;

import {struct} from 'rusted';
 
let Position=struct({
    x:'number', // accepts if typeof x=="number"
    y:'number'  // accepts if typeof y=="number"
});
 
let Player=struct({
    name:'string', // accepts if typeof name=="string"
    position:Position, // accepts if position.constructor==Position
    items:Array, // accepts if items.constructor==Array
    memory:'any' // accepts any type
});
 
let player=Player({
    name:'foo',
    position:Position({
        x:0,y:0
    }),
    items:[],
    memory:{}
});
 
console.log(player.position.x); // > 0

import {Enum,struct,match,impl} from 'rusted';
 
// For struct
let SomeStruct=struct({
    x:'number',y:'number'
});
 
impl(SomeStruct,{
    // You can define associated function (static method) by starting method name with "$".
    $new(x,y){
        return SomeStruct({x,y});
    },
    print(self){
        console.log(`(${x},${y})`);
    }
});
 
let some_struct=SomeStruct.new(2,3); // You don't need to attach "$" at first. "$" was removed at attaching proccess
some_struct.print(); // > (2,3)
 
// For enum
let SomeEnum=Enum({
    Foo:null,
    Bar:'number'
});
 
impl(SomeEnum,{
    unwrap(self){
        return match(self,{
            Foo:()=>'Foo!',
            Bar:x=>`Bar,${x}!`
        });
    }
});
 
let x=SomeEnum.Foo,y=SomeEnum.Bar(7);
console.log(x.unwrap()); // > Foo!
console.log(y.unwrap()); // > Bar,7!
 
// For ordinary constructor (javascript class)
let SomeConstructor=function(){
    this.name='foo';
};
 
impl(SomeConstructor,{
    create(){
        return new SomeConstructor();
    },
    greet(self){
        console.log(`Hello, ${self.name} !`);
    }
});
 
let some_constructor=SomeConstructor.create();
some_constructor.greet(); // > Hello, foo !

import {struct,trait,impl} from 'rusted';
 
let Foo=struct({
    name:'string'
});
 
let BarTrait=trait({
    print(self){}, // empty body, need to implement on `impl`
    hello(self){ // has contents, not need to implement on `impl`
        console.log('hello');
    }
});
 
impl(BarTrait,Foo,{
    print(self){
        console.log(self.name);
    }
});
/* This would be error
impl(BarTrait,Foo,{});
*/
 
let foo=Foo({name:'Taro'});
foo.print(); // > Taro
foo.hello(); // > hello

import {Some,None,match} from 'rusted';
 
let divide=(numerator,denominator)=>{
    return denominator==0
        ? None // represents there are no data
        : 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...

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

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());