MLstruct demonstration

MLstruct online demonstration

class None: {}
class Some[A]: { value: A }
type Option[A] = Some[A] | None

def flatMap f opt = case opt of
  Some -> f opt.value,
  None -> None{}

res = flatMap (fun x -> x) (Some{value = 42})

case res of int -> res, None -> 0

def flatMap2 f opt =
  case opt of Some -> f opt.value, _ -> opt

ex1 = flatMap2 (fun x -> x) 42

ex2 = flatMap2 (fun x -> Some{value = x}) (Some{value = 12})

ex3 = flatMap2 (fun x -> Some{value = x}) 42

def mapSome f opt =
  case opt of Some -> f opt, _ -> opt

class SomeAnd[A, P]: Some[A] & { payload: P }

let arg =
  if true then SomeAnd{value = 42; payload = 23} else None{}
  in mapSome (fun x -> x.value + x.payload) arg

class Cons[A]: Some[A] & { tail: List[A] }
type List[A] = Cons[A] | None

rec def mapList f ls = case ls of
  Cons -> Cons{value = f ls.value; tail = mapList f ls.tail},
  None -> None{}

def Cons head tail = Cons { value = head; tail = tail }

def None = None{}

rec def unzip xs = case xs of
  None -> { fst = None; snd = None },
  Some -> let tmp = unzip xs.tail
          in { fst = Cons xs.value.fst tmp.fst ;
               snd = Cons xs.value.snd tmp.snd }

def Cons_tpd:
  'a -> ('b & List['a]) -> (Cons['a] & { value: 'a; tail: 'b })
def unzip_tpd:
  List[{ fst: 'a; snd: 'b }] -> { fst: List['a]; snd: List['b] }

def Cons_tpd = Cons
def unzip_tpd = unzip

The code is available on github.

Note: JavaScript code generation (used to evaluate results) is not prefect yet and has rough edges.

Syntax Reference

Feature	Type syntax	Term syntax
Basic Terms & Types
literals	`true`, `false`, `0`, `1`, `""`, `"a"`, etc.	(same syntax)
intersection	`S & T`
union	`S \| T`	`if ... then s else t`
negation	`~T`
nominal tag	`#C`
record	`{ x: int; y: bool }`	`{ x = 0; y = false }`
selection		`t.a`
array of known size (tuple)	`()`, `(int,)`, `(int, int)` etc.	`()`, `(0,)`, `(0, 1)` etc.
array of unknown size	`Array[int]`	`if ... then (0, 1) else (0, 1, 2)`
function	`int -> int`	`fun x -> x + 1`
application	`F[A]`	`f a`
variable	`'a`	`x`
let binding		`let x = s in t`
pattern matching 1		`case t of C1 -> t1, C2 -> t2`
pattern matching 2		`case t of C1 -> t1, C2 -> t2, _ -> t3`
Top-Level Declarations
definition	`def foo: T`	`def foo = t` or just `foo = t`
class, trait, method	`trait MyBase[T]: { fld1: T } method Foo: T -> T method Bar = this.Foo this.fld1 class MyClass[A]: MyBase[int] & { fld1: int; fld2: A } method Foo x = x + 1`	`mc = MyClass { fld1 = 0; fld2 = "ok" } mc.Bar`
type alias	`type Foo[T] = MyClass[(T, T)] -> MyClass[T]`
Miscellaneous
type ascription		`t: T`
array indexing		`a[i]`
multi-parameter function	`(int, int) -> int`	`fun (x, y) -> x + y`
multi-argument application	`F[S, T]`	`f(s, t)`
tuple-parameter function	`((int, int)) -> int`	`fun ((x, y)) -> x + y`
tuple-argument application	`F[(S, T)]`	`f((s, t))`

Feature

Type syntax

Term syntax

Basic Terms & Types

literals

true, false, 0, 1, "", "a", etc.

(same syntax)

intersection

S & T

union

S | T

if ... then s else t

negation

~T

nominal tag

#C

record

{ x: int; y: bool }

{ x = 0; y = false }

selection

t.a

array of known size (tuple)

(), (int,), (int, int) etc.

(), (0,), (0, 1) etc.

array of unknown size

Array[int]

if ... then (0, 1) else (0, 1, 2)

function

int -> int

fun x -> x + 1

application

F[A]

f a

variable

'a

x

let binding

let x = s in t

pattern matching 1

case t of C1 -> t1, C2 -> t2

pattern matching 2

case t of C1 -> t1, C2 -> t2, _ -> t3

Top-Level Declarations

definition

def foo: T

def foo = t or just foo = t

class, trait, method


      trait MyBase[T]: { fld1: T }
      
  method Foo: T -> T
      
  method Bar = this.Foo this.fld1
      

      
class MyClass[A]: MyBase[int] & {
      
    fld1: int; fld2: A }
      
  method Foo x = x + 1

mc = MyClass { fld1 = 0; fld2 = "ok" }

mc.Bar

type alias

type Foo[T] =
  MyClass[(T, T)] -> MyClass[T]

Miscellaneous

type ascription

t: T

array indexing

a[i]

multi-parameter function

(int, int) -> int

fun (x, y) -> x + y

multi-argument application

F[S, T]

f(s, t)

tuple-parameter function

((int, int)) -> int

fun ((x, y)) -> x + y

tuple-argument application

F[(S, T)]

f((s, t))