Macro fungi_lang::fgi_exp
[−]
[src]
macro_rules! fgi_exp { { fromast $ast:expr } => { ... }; { ^ $ast:expr } => { ... }; { unsafe ($arity:expr) $rustfn:path } => { ... }; { use $path:ident :: * ; $($e:tt)* } => { ... }; { decls $d:tt ; $($e:tt)+ } => { ... }; { decls $d:tt $($e:tt)+ } => { ... }; { $e:tt : $($c:tt)+ } => { ... }; { $e:tt : $($c:tt)+ } => { ... }; { {$($e:tt)+} } => { ... }; { ws $v:tt $($e:tt)+ } => { ... }; { ret $($v:tt)+ } => { ... }; { #$x:ident.$($e:tt)+ } => { ... }; { fix $x:ident.$($e:tt)+ } => { ... }; { fix ^ $x:ident.$($e:tt)+ } => { ... }; { unroll match $v:tt $($more:tt)+ } => { ... }; { unroll $v:tt $x:ident.$($e:tt)+ } => { ... }; { unpack ($idx:ident,$($idxs:ident),+) $var:ident = $val:tt $($exp:tt)+ } => { ... }; { unpack ($idx:ident) $var:ident = $val:tt $($exp:tt)+ } => { ... }; { unpack $idxs:tt $var:ident = {$($e1:tt)+} $($e2:tt)+ } => { ... }; { {$($e:tt)+} {!$ref:ident} $($more:tt)* } => { ... }; { {$($e:tt)+} [$i:tt] } => { ... }; { {$($e:tt)+} [$i:tt] $($more:tt)+ } => { ... }; { {$($e:tt)+} $v:tt } => { ... }; { {$($e:tt)+} $v:tt $($more:tt)+ } => { ... }; { type $t:ident = $a:tt $($e:tt)+ } => { ... }; { let $x:ident = $e1:tt $($e2:tt)+ } => { ... }; { let $x:ident : $a:tt = $e1:tt $($e2:tt)+ } => { ... }; { let rec $x:ident : $a:tt = $e1:tt $($e2:tt)+ } => { ... }; { thk $v:tt $($e:tt)+ } => { ... }; { ref $v1:tt $($v2:tt)+ } => { ... }; { force $($v:tt)+ } => { ... }; { refthunk $($v:tt)+ } => { ... }; { get $($v:tt)+ } => { ... }; { let ($($vars:tt)+) = {$($e1:tt)+} $($e2:tt)+ } => { ... }; { let ($($vars:tt)+) = $v:tt $($e:tt)+ } => { ... }; { match $v:tt {$x1:ident=>$e1:tt $x2:ident=>$e2:tt} } => { ... }; { match $v:tt {$x1:ident=>$e1:tt $x2:ident=>$e2:tt $($more:tt)+} } => { ... }; { memo{$($e1:tt)+}{$($e2:tt)+} } => { ... }; { memo($($v:tt)+){$($e:tt)+} } => { ... }; { match $v:tt {$x1:ident=>$e1:tt $x2:ident=>$e2:tt} } => { ... }; { if ( $($v:tt)+ ) { $($e1:tt)+ } else { $($e2:tt)+ } } => { ... }; { if { $($e:tt)+ } { $($e1:tt)+ } else { $($e2:tt)+ } } => { ... }; { [$($v1:tt)+] $v2:tt } => { ... }; { [$($v1:tt)+] $v2:tt $($more:tt)+ } => { ... }; { $v1:tt, $v2:tt } => { ... }; { $v1:tt, $($more:tt)+ } => { ... }; { $v1:tt < $v2:tt } => { ... }; { $v1:tt == $v2:tt } => { ... }; { $v1:tt <= $v2:tt } => { ... }; { $v1:tt + $v2:tt } => { ... }; { unimplemented } => { ... }; { label [$($n:tt)+]($($s:tt)+) $($e:tt)+ } => { ... }; { label ($($s:tt)+)[$($n:tt)+] $($e:tt)+ } => { ... }; { label ($($s:tt)+) $($e:tt)+ } => { ... }; { label [$($n:tt)+] $($e:tt)+ } => { ... }; { $($any:tt)* } => { ... }; }
Parser for expressions
e::=
fromast ast (inject ast nodes)
unsafe (arity) rustfn (inject an evaluation function written in Rust)
use x :: * ; e (all decls in module x made local to e)
decls { d } ; e (all decls in d are made local to e)
decls { d } e (optional semicolon)
e : C (type annotation, no effect)
e :> E (type annotation, with effect)
{e} (parens)
ws v e (write scope)
ret v (lifted value)
#x.e (lambda)
fix x.e (recursive lambda)
unroll v x.e (unroll recursively-typed value v as x in e)
unroll match v { ... } (unroll recursively-typed value and elim sum type)
unpack (a1,...) x = (v) e (unpack existentials from type, bind x to v)
{e} [i1] ... (extened index application)
{e} {!ref} ... (application get-sugar)
{e} v1 ... (extened application)
type t = (A) e (user type shorthand)
let x = {e1} e2 (let-binding)
let x : A = {e1} e2 (annotated let-binding)
let rec x : A = {e1} e2 (annotated let-rec binding)
thk v e (create thunk)
ref v1 v2 (create ref)
force v (force thunk)
refthunk v (coerce a value-producing thunk to a ref)
get v (read from ref)
let (x1,...) = {e1} e2 (let-split sugar)
let (x1,...) = v e (extended split)
memo{e1}{e2} (memoize computation, sugar - compute name)
memo(v){e} (memoize computation by name, return ref)
match v {x1 => e1 ... } (extended case analysis)
if { e } { e1 } else { e2 } (if-then-else; bool elim)
if ( v ) { e1 } else { e2 } (if-then-else; bool elim)
[v1] v2 ... (curried name function application)
v1, v2, ... (extended binary name construction)
v1 < v2 (less-than)
unimplemented (marker for type checker)
label (some text) e (debug string label)
label [n] e (debug name label)
label (some text)[n] e (debug string and name label)
label [n](some text) e (debug string and name label)