yal

func ADD ¶

func ADD(node Node) ast.Expr

ADD returns expression for addition.

(  a b)

func ARRAY ¶

func ARRAY(node Node) ast.Expr

ARRAY returns composite literal expression for array. First node represents element type. Second node represents array size.

(array type n a b)

func ASSIGN ¶

func ASSIGN(node Node) ast.Stmt

ASSIGN returns "=" statement. Accepts multiple arguments.

(= a b c d)

Becomes:

a, c = b, d

func Buffer ¶

func Buffer(file *ast.File) (*bytes.Buffer, error)

func DEFINE ¶

func DEFINE(node Node) ast.Stmt

DEFINE returns ":=" statement. Accepts multiple arguments.

(:= a b c d)

Becomes:

a, c := b, d

func EQL ¶

func EQL(node Node) ast.Expr

EQL returns expression for equality.

(== a b)

func GEQ ¶

func GEQ(node Node) ast.Expr

GEQ returns "greater than or equal" expression.

(>= a b)

func GTR ¶

func GTR(node Node) ast.Expr

GTR returns "greater than" expression.

(> a b)

func IF ¶

func IF(node Node) ast.Stmt

IF returns "if" statement.

(if a b)

Becomes:

if a {
  b
}

func LAND ¶

func LAND(node Node) ast.Expr

LAND returns "and" expression.

(&& a b)

func LEQ ¶

func LEQ(node Node) ast.Expr

LEQ returns "less than or equal" expression.

(<= a b)

func LOR ¶

func LOR(node Node) ast.Expr

LOR returns "or" expression.

(<= a b)

func LSS ¶

func LSS(node Node) ast.Expr

LSS returns "less than" expression.

(< a b)

func MAP ¶

func MAP(node Node) ast.Expr

MAP generates anonymous function which applies function `f` to each element in slice `a` and returns new slice. Function `f` should have one argument and return value with same type.

(map type type f a)

func MUL ¶

func MUL(node Node) ast.Expr

MUL returns expression for multiplication.

(* a b)

func NEQ ¶

func NEQ(node Node) ast.Expr

NEQ returns expression for inequality.

(!= a b)

func QUO ¶

func QUO(node Node) ast.Expr

QUO returns expression for division.

(/ a b)

func REM ¶

func REM(node Node) ast.Expr

REM returns expression for remainder.

(% a b)

func RETURN ¶

func RETURN(node Node) ast.Stmt

RETURN returns "return" statement. Accepts multiple arguments.

(return a b c)

Becomes:

return a, b, c

func SLICE ¶

func SLICE(node Node) ast.Expr

SLICE returns composite literal expression for slice. First node represents element type.

(slice type a b)

func SUB ¶

func SUB(node Node) ast.Expr

SUB returns expression for subtraction.

(- a b)

func SWITCH ¶

func SWITCH(node Node) ast.Stmt

SWITCH returns "switch" statement. Accepts multiple arguments.

(switch a b c)

Becomes:

switch a {
  case b: c
}

func VAR ¶

func VAR(node Node) ast.Stmt

VAR returns "var" statement.

(var a b)

Becomes:

var a b