lib

Documentation

Index

• Variables
• type DotEnv
  • func (e *DotEnv) Lookup(s *exp.Sym, p cor.Path, eval bool) (lit.Val, error)
  • func (e *DotEnv) Parent() exp.Env
• type FuncEnv
  • func (e *FuncEnv) Lookup(s *exp.Sym, p cor.Path, eval bool) (lit.Val, error)
  • func (e *FuncEnv) Parent() exp.Env
• type Specs
  • func (sm Specs) Add(ss ...exp.Spec) Specs
  • func (sm Specs) AddMap(m map[string]exp.Spec) Specs

Variables

var (
	Or  = &logicSpec{impl("<form@or  tupl? bool>"), false, false, true}
	Ok  = &logicSpec{impl("<form@ok  tupl? bool>"), false, true, false}
	And = &logicSpec{impl("<form@and tupl? bool>"), true, true, false}
	Not = &logicSpec{impl("<form@not tupl? bool>"), true, true, true}
)

var (
	Eq    = &compSpec{impl("<form@eq any tupl bool>"), 0, false}
	Equal = &compSpec{impl("<form@equal any tupl bool>"), 0, false}
	Ne    = &compSpec{impl("<form@ne any tupl bool>"), 0, true}
	Lt    = &compSpec{impl("<form@lt <alt num str span time> tupl|_ bool>"), -1, false}
	Ge    = &compSpec{impl("<form@ge <alt num str span time> tupl|_ bool>"), -1, true}
	Gt    = &compSpec{impl("<form@gt <alt num str span time> tupl|_ bool>"), 1, false}
	Le    = &compSpec{impl("<form@le <alt num str span time> tupl|_ bool>"), 1, true}
)

var (
	In = &inSpec{impl("<form@in any tupl|list bool>"), false}
	Ni = &inSpec{impl("<form@ni any tupl|list bool>"), true}
)

var Abs = &absSpec{impl("<form@abs num@ _>")}

var Add = &addSpec{impl("<form@add num@ tupl?|num _>")}

var Call = &callSpec{impl("<form@call spec tupl|exp lit|_>")}

var Cat = &catSpec{impl("<form@cat tupl str>")}

var Core = exp.Builtins(make(Specs).Add(
	Or, And, Ok, Not, Err,
	Add, Sub, Mul, Div, Rem, Abs, Neg, Min, Max,
	Eq, Ne, Lt, Ge, Gt, Le, In, Ni, Equal,
	If, Swt, Df,
	Cat, Sep, Xelf, Json,
	Make, Sel, Len,
))

Core is a builtin environment with foundational specs.

var Df = &dfSpec{impl("<form@df tupl|@1 @1!>")}

var Div = &divSpec{impl("<form@div num@ tupl|num _>")}

var Do = &doSpec{impl("<form@do tupl|exp @>")}

var Err = &errSpec{impl("<form@err tupl?|exp @>")}

var Fn = &fnSpec{impl("<form@fn tupl?|tag|typ exp|@1 spec|@1>")}

var Fold = &foldSpec{impl("<form@fold list|@1 @2 <func @2 @1 @2> @2>"), false}

var Foldr = &foldSpec{impl("<form@foldr list|@1 @2 <func @2 @1 @2> @2>"), true}

var If = &ifSpec{impl("<form@if <tupl cond:any then:exp|@1> else:exp?|@1 @1>")}

var Json = &rawSpec{impl("<form@json any raw>"), true}

var Len = &lenSpec{impl("<form@len <alt? list keyr str raw> int>")}

var Make = &makeSpec{impl("<form@make typ tupl?|exp lit|_>")}

var Max = &maxSpec{impl("<form@max num@ tupl?|num _>")}

var Min = &minSpec{impl("<form@min num@ tupl?|num _>")}

var Mul = &mulSpec{impl("<form@mul num@ tupl?|num _>")}

var Mut = &mutSpec{impl("<form@mut any@ tupl?|exp _>")}

var Neg = &negSpec{impl("<form@neg num@ _>")}

var Range = &rangeSpec{impl("<form@range n:int f?:<func int @1> list|@1>")}

var Rem = &remSpec{impl("<form@rem int int int>")}

var Sel = &selSpec{impl("<form@sel sym <tupl?|alt str int> @>")}

var Sep = &sepSpec{impl("<form@sep str tupl str>")}

var Std = exp.Builtins(make(Specs).AddMap(Core).Add(
	Do, Call,
	With,
	Mut,
	Fn,
	Fold, Foldr, Range,
))

Std extends the core environment with commonly used specs.

var Sub = &subSpec{impl("<form@sub num@ tupl|num _>")}

var Swt = &swtSpec{impl("<form@swt @1 <tupl case:@1 then:exp|@2> else:exp?|@2 @2>")}

var With = &withSpec{impl("<form@with dot?:any lets:tupl?|tag exp|@1 @1>")}

var Xelf = &rawSpec{impl("<form@xelf any raw>"), false}

Types

type DotEnv

type DotEnv struct {
	Par  exp.Env
	Dot  lit.Val
	Lets *lit.Obj
}

DotEnv is a child scope that supports relative paths into either a dot literals or name values.

func (*DotEnv) Lookup

func (e *DotEnv) Lookup(s *exp.Sym, p cor.Path, eval bool) (lit.Val, error)

func (*DotEnv) Parent

func (e *DotEnv) Parent() exp.Env

type FuncEnv

type FuncEnv struct {
	Par exp.Env
	Def lit.Keyed
	// contains filtered or unexported fields
}

func (*FuncEnv) Lookup

func (e *FuncEnv) Lookup(s *exp.Sym, p cor.Path, eval bool) (lit.Val, error)

func (*FuncEnv) Parent

func (e *FuncEnv) Parent() exp.Env

type Specs

type Specs map[string]exp.Spec

Specs is spec map helper that can be converted to a builtin environment.

func (Specs) Add

func (sm Specs) Add(ss ...exp.Spec) Specs

Add add all specs to this spec map.

func (Specs) AddMap

func (sm Specs) AddMap(m map[string]exp.Spec) Specs

AddMap add all specs for map m to this spec map.