ast

package

Go to main page

Versions in this module

v0

v0.4.10

May 31, 2017

Changes in this version

+ var Base64UrlDecode = &Builtin

+ var Base64UrlEncode = &Builtin

+ var JWTDecode = &Builtin

+ var Min = &Builtin

+ var Replace = &Builtin

+ var Split = &Builtin

+ var Sprintf = &Builtin

+ var Trim = &Builtin

+ func WalkRules(x interface{}, f func(*Rule) bool)

+ type IndexResult struct

+ Default *Rule

+ Else map[*Rule][]*Rule

+ Rules []*Rule

+ func NewIndexResult() *IndexResult

+ func (ir *IndexResult) Empty() bool

+ func (ir *IndexResult) Kind() DocKind

type Rule

+ Else *Rule

type RuleIndex

+ Lookup func(resolver ValueResolver) (result *IndexResult, err error)

type VarVisitorParams

+ SkipSets bool

v0.4.9

May 16, 2017

Changes in this version

+ var JSONMarshal = &Builtin

+ var JSONUnmarshal = &Builtin

+ func IsConstant(v Value) bool

+ func JSON(v Value) (interface{}, error)

+ func ValueToInterface(v Value, resolver Resolver) (interface{}, error)

+ func WalkExprs(x interface{}, f func(*Expr) bool)

+ type ArgErrDetail struct

+ Have []types.Type

+ Want []types.Type

+ func (d *ArgErrDetail) Lines() []string

type Array

+ func (arr Array) Get(pos *Term) *Term

type Builtin

+ Args []types.Type

type Compiler

+ TypeEnv *TypeEnv

+ func (c *Compiler) RuleIndex(path Ref) RuleIndex

type Error

+ Details ErrorDetails

+ type ErrorDetails interface

+ Lines func() []string

type Expr

+ func (expr *Expr) Builtin() *Builtin

+ func (expr *Expr) IsBuiltin() bool

+ func (expr *Expr) Operand(pos int) *Term

+ func (expr *Expr) Operands() []*Term

type Module

+ func (mod *Module) RuleSet(name Var) RuleSet

type QueryCompiler

+ TypeEnv func() *TypeEnv

type Ref

+ func (ref Ref) Dynamic() int

+ type RefErrDetail struct

+ Index int

+ Ref Ref

+ Referrer types.Type

+ Refers types.Type

+ func (r *RefErrDetail) Lines() []string

+ type Resolver interface

+ Resolve func(ref Ref) (value interface{}, err error)

type Rule

+ Module *Module

+ type RuleGraph struct

+ func NewRuleGraph(modules map[string]*Module, list func(Ref) []*Rule) *RuleGraph

+ func (g *RuleGraph) Dependencies(rule *Rule) map[*Rule]struct{}

+ func (g *RuleGraph) Sort() (sorted []*Rule, ok bool)

+ type RuleIndex interface

+ Build func(rules []*Rule) (ok bool)

+ Index func(resolver ValueResolver) (rules []*Rule, defaultRule *Rule, err error)

+ type RuleSet []*Rule

+ func NewRuleSet(rules ...*Rule) RuleSet

+ func (rs *RuleSet) Add(rule *Rule)

+ func (rs RuleSet) Contains(rule *Rule) bool

+ func (rs RuleSet) Diff(other RuleSet) RuleSet

+ func (rs RuleSet) Equal(other RuleSet) bool

+ func (rs RuleSet) Merge(other RuleSet) RuleSet

+ func (rs RuleSet) String() string

+ type TypeEnv struct

+ func NewTypeEnv() *TypeEnv

+ func (env *TypeEnv) Get(x interface{}) types.Type

+ type UnificationErrDetail struct

+ Left types.Type

+ Right types.Type

+ func (a *UnificationErrDetail) Lines() []string

+ type ValueResolver interface

+ Resolve func(ref Ref) (value Value, err error)

v0.4.8

Apr 5, 2017

v0.4.7

Mar 22, 2017

v0.4.6

Mar 12, 2017

v0.4.5

Feb 23, 2017

Changes in this version

+ const InputErr

+ const TypeErr

+ var SystemDocumentKey = String("system")

type Array

+ func (arr Array) Find(path []string) (Value, error)

type ArrayComprehension

+ func (ac *ArrayComprehension) Find(path []string) (Value, error)

type Boolean

+ func (bol Boolean) Find(path []string) (Value, error)

type ModuleTreeNode

+ Hide bool

type Null

+ func (null Null) Find(path []string) (Value, error)

type Number

+ func (num Number) Find(path []string) (Value, error)

type Object

+ func (obj Object) Find(path []string) (Value, error)

type Ref

+ func (ref Ref) Find(path []string) (Value, error)

type RuleTreeNode

+ Hide bool

type Set

+ func (s *Set) Find(path []string) (Value, error)

type String

+ func (str String) Find(path []string) (Value, error)

type Value

+ func MustInterfaceToValue(x interface{}) Value

+ Find func(path []string) (Value, error)

type Var

+ func (v Var) Find(path []string) (Value, error)

v0.4.4

Feb 15, 2017

v0.4.3

Feb 14, 2017

Changes in this version

+ var RootDocumentNames = &Set

+ var RootDocumentRefs = &Set

type RuleTreeNode

+ func (n *RuleTreeNode) Child(k Value) *RuleTreeNode

v0.4.2

Feb 10, 2017

Changes in this version

+ var And = &Builtin

+ var Or = &Builtin

type Set

+ func (s *Set) Intersect(other *Set) *Set

+ func (s *Set) Union(other *Set) *Set

v0.4.1

Feb 3, 2017

Changes in this version

+ const ConflictingInputErr

+ const UndefinedInputErr

+ const WithTypeName

+ func WalkWiths(x interface{}, f func(*With) bool)

type Body

+ func (body *Body) Append(expr *Expr)

type Expr

+ With []*With

+ func (expr *Expr) IncludeWith(target *Term, value *Term) *Expr

+ func (expr *Expr) NoWith() *Expr

type GenericVisitor

+ func NewGenericVisitor(f func(x interface{}) bool) *GenericVisitor

type Head

+ Location *Location

+ func NewHead(name Var, args ...*Term) *Head

+ func (head *Head) Compare(other *Head) int

+ func (head *Head) Copy() *Head

+ func (head *Head) DocKind() DocKind

+ func (head *Head) Equal(other *Head) bool

+ func (head *Head) Vars() VarSet

type QueryContext

+ func (qc *QueryContext) InputDefined() bool

type Rule

+ Default bool

type VarVisitorParams

+ SkipWithTarget bool

+ type With struct

+ Location *Location

+ Target *Term

+ Value *Term

+ func (w *With) Compare(other *With) int

+ func (w *With) Copy() *With

+ func (w *With) Equal(other *With) bool

+ func (w *With) String() string

+ func (w With) Hash() int

v0.4.0

Jan 25, 2017

Changes in this version

+ const BodyTypeName

+ const ExprTypeName

+ const HeadTypeName

+ const ImportTypeName

+ const MissingInputErr

+ const PackageTypeName

+ const RuleTypeName

+ var InputRootDocument = VarTerm("input")

+ var InputRootRef = Ref

+ func IsError(code ErrCode, err error) bool

+ type Comment struct

+ Location *Location

+ Text []byte

+ func NewComment(text []byte) *Comment

+ func (c *Comment) Loc() *Location

+ func (c *Comment) String() string

type Compiler

+ func (c *Compiler) GetRules(ref Ref) (rules []*Rule)

type QueryContext

+ Input Value

+ func (qc *QueryContext) WithImports(imports []*Import) *QueryContext

+ func (qc *QueryContext) WithInput(input Value) *QueryContext

+ func (qc *QueryContext) WithPackage(pkg *Package) *QueryContext

type Set

+ func (s *Set) Iter(f func(*Term) bool) (stop bool)

+ func (s *Set) Reduce(i *Term, f func(*Term, *Term) (*Term, error)) (*Term, error)

v0.3.1

Dec 23, 2016

Changes in this version

type VarVisitorParams

+ SkipBuiltinOperators bool

v0.3.0

Dec 20, 2016

Changes in this version

+ const ArrayComprehensionTypeName

+ const ArrayTypeName

+ const BooleanTypeName

+ const NullTypeName

+ const NumberTypeName

+ const ObjectTypeName

+ const RefTypeName

+ const SetTypeName

+ const StringTypeName

+ const VarTypeName

+ var RequestRootDocument = VarTerm("request")

+ var RequestRootRef = Ref

+ func IsValidImportPath(v Value) (err error)

+ func TypeName(x interface{}) string

type Array

+ func (arr Array) MarshalJSON() ([]byte, error)

type Compiler

+ func (c *Compiler) WithModuleLoader(f ModuleLoader) *Compiler

+ type ModuleLoader func(resolved map[string]*Module) (parsed map[string]*Module, err error)

type Number

+ func (num Number) Int() (int, bool)

+ func (num Number) MarshalJSON() ([]byte, error)

type Object

+ func (obj Object) MarshalJSON() ([]byte, error)

type Ref

+ func (ref Ref) Extend(other Ref) Ref

type Rule

+ func ParseRuleFromBody(body Body) *Rule

type Term

+ func FloatNumberTerm(f float64) *Term

+ func IntNumberTerm(i int) *Term

+ type VarVisitor struct

+ func NewVarVisitor() *VarVisitor

+ func (vis *VarVisitor) Vars() VarSet

+ func (vis *VarVisitor) Visit(v interface{}) Visitor

+ func (vis *VarVisitor) WithParams(params VarVisitorParams) *VarVisitor

+ type VarVisitorParams struct

+ SkipBuiltinNames bool

+ SkipClosures bool

+ SkipObjectKeys bool

+ SkipRefHead bool

v0.2.2

Dec 1, 2016

Changes in this version

+ var DefaultRootRef = Ref

+ var SetDiff = &Builtin

+ func IsKeyword(s string) bool

type Array

+ func (arr Array) Copy() Array

type ArrayComprehension

+ func (ac *ArrayComprehension) Copy() *ArrayComprehension

type Body

+ func (body Body) Copy() Body

type Compiler

+ func (c *Compiler) QueryCompiler() QueryCompiler

type Expr

+ func (expr *Expr) Copy() *Expr

type Import

+ func MustParseImports(input string) []*Import

+ func ParseImports(input string) ([]*Import, error)

+ func (imp *Import) Copy() *Import

+ func (imp *Import) Name() Var

type Location

+ func (loc *Location) String() string

type Module

+ func (mod *Module) Copy() *Module

type ModuleTreeNode

+ func (n *ModuleTreeNode) DepthFirst(f func(node *ModuleTreeNode) bool)

type Object

+ func (obj Object) Copy() Object

type Package

+ func MustParsePackage(input string) *Package

+ func ParsePackage(input string) (*Package, error)

+ func (pkg *Package) Copy() *Package

+ type QueryCompiler interface

+ Compile func(q Body) (Body, error)

+ WithContext func(qctx *QueryContext) QueryCompiler

+ type QueryContext struct

+ Imports []*Import

+ Package *Package

+ func NewQueryContext(pkg *Package, imports []*Import) *QueryContext

+ func NewQueryContextForModule(mod *Module) *QueryContext

+ func (qc *QueryContext) Copy() *QueryContext

type Ref

+ func (ref Ref) Copy() Ref

type Rule

+ func (rule *Rule) Copy() *Rule

type RuleTreeNode

+ func (n *RuleTreeNode) DepthFirst(f func(node *RuleTreeNode) bool)

type Set

+ func (s *Set) Copy() *Set

type Term

+ func (term *Term) Copy() *Term

v0.2.1

Nov 23, 2016

Changes in this version

+ var Contains = &Builtin

+ var EndsWith = &Builtin

+ var IndexOf = &Builtin

+ var Lower = &Builtin

+ var StartsWith = &Builtin

+ var Substring = &Builtin

+ var Upper = &Builtin

+ func WalkVars(x interface{}, f func(Var) bool)

type Expr

+ func NewExpr(terms interface{}) *Expr

type Term

+ func NewTerm(v Value) *Term

type VarSet

+ func (s VarSet) Equal(vs VarSet) bool

v0.2.0

Nov 7, 2016

Changes in this version

+ const CompileErr

+ const ParseErr

+ const RecursionErr

+ const UnsafeVarErr

+ var Concat = &Builtin

+ var FormatInt = &Builtin

+ var RegexMatch = &Builtin

+ func Compare(a, b interface{}) int

+ func CompileModule(m string) (*Compiler, *Module, error)

+ func CompileQuery(q string) (*Compiler, Body, error)

+ func IsScalar(v Value) bool

+ func Transform(t Transformer, x interface{}) (interface{}, error)

+ func TransformRefs(x interface{}, f func(Ref) (Value, error)) (interface{}, error)

+ func WalkBodies(x interface{}, f func(Body) bool)

type Body

+ func NewBody(exprs ...*Expr) Body

+ func (body Body) Compare(other Body) int

type Builtin

+ Infix Var

type Compiler

+ RuleTree *RuleTreeNode

+ func (c *Compiler) GetRulesExact(ref Ref) (rules []*Rule)

+ func (c *Compiler) GetRulesForVirtualDocument(ref Ref) (rules []*Rule)

+ func (c *Compiler) GetRulesWithPrefix(ref Ref) (rules []*Rule)

+ type ErrCode int

+ type Error struct

+ Code int

+ Location *Location

+ Message string

+ func NewError(code int, loc *Location, f string, a ...interface{}) *Error

+ func (e *Error) Error() string

+ type Errors []*Error

+ func (e Errors) Error() string

type Expr

+ Index int

+ func MustParseExpr(input string) *Expr

+ func ParseExpr(input string) (*Expr, error)

+ func (expr *Expr) Compare(other *Expr) int

+ type GenericTransformer struct

+ func (t *GenericTransformer) Transform(x interface{}) (interface{}, error)

+ type Head struct

+ Key *Term

+ Name Var

+ Value *Term

+ func (head *Head) String() string

type Import

+ func (imp *Import) Compare(other *Import) int

type Location

+ func (loc *Location) Format(f string, a ...interface{}) string

type Module

+ func (mod *Module) Compare(other *Module) int

+ func (mod *Module) String() string

type Object

+ func (obj Object) Get(k *Term) *Term

+ func (obj Object) Keys() []*Term

type Package

+ func (pkg *Package) Compare(other *Package) int

type Ref

+ func (ref Ref) Append(term *Term) Ref

+ func (ref Ref) GroundPrefix() Ref

+ func (ref Ref) HasPrefix(other Ref) bool

type Rule

+ func (rule *Rule) Compare(other *Rule) int

+ func (rule *Rule) Head() *Head

+ func (rule *Rule) Path(ns Ref) Ref

+ type RuleTreeNode struct

+ Children map[Value]*RuleTreeNode

+ Key Value

+ Rules []*Rule

+ func NewRuleTree(mods map[string]*Module) *RuleTreeNode

+ func (n *RuleTreeNode) Size() int

+ type Set []*Term

+ func (s *Set) Add(t *Term)

+ func (s *Set) Diff(other *Set) *Set

+ func (s *Set) Equal(v Value) bool

+ func (s *Set) Hash() int

+ func (s *Set) IsGround() bool

+ func (s *Set) Map(f func(*Term) (*Term, error)) (*Set, error)

+ func (s *Set) String() string

+ func (s Set) Contains(t *Term) bool

type Term

+ func SetTerm(t ...*Term) *Term

+ type Transformer interface

+ Transform func(v interface{}) (interface{}, error)

+ type ValueMap struct

+ func NewValueMap() *ValueMap

+ func (vs *ValueMap) Copy() *ValueMap

+ func (vs *ValueMap) Delete(k Value)

+ func (vs *ValueMap) Equal(other *ValueMap) bool

+ func (vs *ValueMap) Get(k Value) Value

+ func (vs *ValueMap) Hash() int

+ func (vs *ValueMap) Iter(iter func(Value, Value) bool) bool

+ func (vs *ValueMap) Len() int

+ func (vs *ValueMap) Put(k, v Value)

+ func (vs *ValueMap) String() string

type Var

+ func (v Var) IsWildcard() bool

v0.1.0

Jul 14, 2016

Changes in this version

+ const CompleteDoc

+ const PartialObjectDoc

+ const PartialSetDoc

+ var Abs = &Builtin

+ var BuiltinMap map[Var]*Builtin

+ var Builtins []*Builtin

+ var Count = &Builtin

+ var DefaultBuiltins = [...]*Builtin

+ var DefaultRootDocument = VarTerm("data")

+ var Divide = &Builtin

+ var Equality = &Builtin

+ var GreaterThan = &Builtin

+ var GreaterThanEq = &Builtin

+ var Keywords = [...]string

+ var LessThan = &Builtin

+ var LessThanEq = &Builtin

+ var Max = &Builtin

+ var Minus = &Builtin

+ var Multiply = &Builtin

+ var NotEqual = &Builtin

+ var Plus = &Builtin

+ var ReservedVars = NewVarSet(DefaultRootDocument.Value.(Var))

+ var Round = &Builtin

+ var Sum = &Builtin

+ var ToNumber = &Builtin

+ var Wildcard = &Term

+ var WildcardPrefix = "$"

+ func MustParseStatement(input string) interface

+ func MustParseStatements(input string) []interface

+ func Parse(filename string, b []byte, opts ...Option) (interface{}, error)

+ func ParseFile(filename string, opts ...Option) (interface{}, error)

+ func ParseReader(filename string, r io.Reader, opts ...Option) (interface{}, error)

+ func ParseStatement(input string) (interface{}, error)

+ func ParseStatements(filename, input string) ([]interface{}, error)

+ func RegisterBuiltin(b *Builtin)

+ func Walk(v Visitor, x interface{})

+ func WalkClosures(x interface{}, f func(interface{}) bool)

+ func WalkRefs(x interface{}, f func(Ref) bool)

+ type Array []*Term

+ func (arr Array) Equal(other Value) bool

+ func (arr Array) Hash() int

+ func (arr Array) IsGround() bool

+ func (arr Array) Query(ref Ref, iter QueryIterator) error

+ func (arr Array) String() string

+ type ArrayComprehension struct

+ Body Body

+ Term *Term

+ func (ac *ArrayComprehension) Equal(other Value) bool

+ func (ac *ArrayComprehension) Hash() int

+ func (ac *ArrayComprehension) IsGround() bool

+ func (ac *ArrayComprehension) String() string

+ type Body []*Expr

+ func MustParseBody(input string) Body

+ func ParseBody(input string) (Body, error)

+ func (body Body) Contains(x *Expr) bool

+ func (body Body) Equal(other Body) bool

+ func (body Body) Hash() int

+ func (body Body) IsGround() bool

+ func (body Body) Loc() *Location

+ func (body Body) OutputVars(safe VarSet) VarSet

+ func (body Body) String() string

+ func (body Body) Vars(skipClosures bool) VarSet

+ type Boolean bool

+ func (bol Boolean) Equal(other Value) bool

+ func (bol Boolean) Hash() int

+ func (bol Boolean) IsGround() bool

+ func (bol Boolean) String() string

+ type Builtin struct

+ Alias Var

+ Name Var

+ NumArgs int

+ TargetPos []int

+ func (b *Builtin) Expr(terms ...*Term) *Expr

+ func (b *Builtin) GetPrintableName() string

+ func (b *Builtin) IsTargetPos(i int) bool

+ type Compiler struct

+ Errors []error

+ Exports *util.HashMap

+ Globals map[*Module]map[Var]Value

+ ModuleTree *ModuleTreeNode

+ Modules map[string]*Module

+ RuleGraph map[*Rule]map[*Rule]struct{}

+ func NewCompiler() *Compiler

+ func (c *Compiler) Compile(mods map[string]*Module)

+ func (c *Compiler) Failed() bool

+ func (c *Compiler) FlattenErrors() string

+ type DocKind int

+ type Expr struct

+ Location *Location

+ Negated bool

+ Terms interface{}

+ func NewBuiltinExpr(terms ...*Term) *Expr

+ func (expr *Expr) Complement() *Expr

+ func (expr *Expr) Equal(other *Expr) bool

+ func (expr *Expr) Hash() int

+ func (expr *Expr) IsEquality() bool

+ func (expr *Expr) IsGround() bool

+ func (expr *Expr) OutputVars(safe VarSet) VarSet

+ func (expr *Expr) String() string

+ func (expr *Expr) UnmarshalJSON(bs []byte) error

+ func (expr *Expr) Vars(skipClosures bool) VarSet

+ type GenericVisitor struct

+ func (vis *GenericVisitor) Visit(x interface{}) Visitor

+ type Import struct

+ Alias Var

+ Location *Location

+ Path *Term

+ func (imp *Import) Equal(other *Import) bool

+ func (imp *Import) Loc() *Location

+ func (imp *Import) String() string

+ type Location struct

+ Col int

+ File string

+ Row int

+ Text []byte

+ func NewLocation(text []byte, file string, row int, col int) *Location

+ func (loc *Location) Errorf(f string, a ...interface{}) error

+ func (loc *Location) Wrapf(err error, f string, a ...interface{}) error

+ type Module struct

+ Imports []*Import

+ Package *Package

+ Rules []*Rule

+ func MustParseModule(input string) *Module

+ func ParseModule(filename, input string) (*Module, error)

+ func (mod *Module) Equal(other *Module) bool

+ type ModuleTreeNode struct

+ Children map[string]*ModuleTreeNode

+ Key string

+ Modules []*Module

+ func NewModuleTree(mods map[string]*Module) *ModuleTreeNode

+ func (n *ModuleTreeNode) Size() int

+ type Null struct

+ func (null Null) Equal(other Value) bool

+ func (null Null) Hash() int

+ func (null Null) IsGround() bool

+ func (null Null) String() string

+ type Number float64

+ func (num Number) Equal(other Value) bool

+ func (num Number) Hash() int

+ func (num Number) IsGround() bool

+ func (num Number) String() string

+ type Object [][2]*Term

+ func (obj Object) Diff(other Object) Object

+ func (obj Object) Equal(other Value) bool

+ func (obj Object) Hash() int

+ func (obj Object) Intersect(other Object) [][3]*Term

+ func (obj Object) IsGround() bool

+ func (obj Object) Merge(other Object) (Object, bool)

+ func (obj Object) Query(ref Ref, iter QueryIterator) error

+ func (obj Object) String() string

+ type Option func(*parser) Option

+ func Debug(b bool) Option

+ func Memoize(b bool) Option

+ func Recover(b bool) Option

+ type Package struct

+ Location *Location

+ Path Ref

+ func (pkg *Package) Equal(other *Package) bool

+ func (pkg *Package) Loc() *Location

+ func (pkg *Package) String() string

+ type QueryIterator func(map[Var]Value, Value) error

+ type Ref []*Term

+ func EmptyRef() Ref

+ func MustParseRef(input string) Ref

+ func ParseRef(input string) (Ref, error)

+ func (ref Ref) Equal(other Value) bool

+ func (ref Ref) Hash() int

+ func (ref Ref) IsGround() bool

+ func (ref Ref) IsNested() bool

+ func (ref Ref) OutputVars() VarSet

+ func (ref Ref) String() string

+ func (ref Ref) Underlying() ([]interface{}, error)

+ type Rule struct

+ Body Body

+ Key *Term

+ Location *Location

+ Name Var

+ Value *Term

+ func MustParseRule(input string) *Rule

+ func ParseConstantRule(body Body) *Rule

+ func ParseRule(input string) (*Rule, error)

+ func (rule *Rule) DocKind() DocKind

+ func (rule *Rule) Equal(other *Rule) bool

+ func (rule *Rule) HeadVars() VarSet

+ func (rule *Rule) Loc() *Location

+ func (rule *Rule) String() string

+ type Statement interface

+ Loc func() *Location

+ type String string

+ func (str String) Equal(other Value) bool

+ func (str String) Hash() int

+ func (str String) IsGround() bool

+ func (str String) String() string

+ type Term struct

+ Location *Location

+ Value Value

+ func ArrayComprehensionTerm(term *Term, body Body) *Term

+ func ArrayTerm(a ...*Term) *Term

+ func BooleanTerm(b bool) *Term

+ func Item(key, value *Term) [2]*Term

+ func MustParseTerm(input string) *Term

+ func NullTerm() *Term

+ func NumberTerm(n float64) *Term

+ func ObjectTerm(o ...[2]*Term) *Term

+ func ParseTerm(input string) (*Term, error)

+ func RefTerm(r ...*Term) *Term

+ func StringTerm(s string) *Term

+ func VarTerm(v string) *Term

+ func (term *Term) Equal(other *Term) bool

+ func (term *Term) Hash() int

+ func (term *Term) IsGround() bool

+ func (term *Term) MarshalJSON() ([]byte, error)

+ func (term *Term) String() string

+ func (term *Term) UnmarshalJSON(bs []byte) error

+ func (term *Term) Vars() VarSet

+ type Value interface

+ Equal func(other Value) bool

+ Hash func() int

+ IsGround func() bool

+ String func() string

+ func InterfaceToValue(x interface{}) (Value, error)

+ type Var string

+ func (variable Var) Equal(other Value) bool

+ func (variable Var) Hash() int

+ func (variable Var) IsGround() bool

+ func (variable Var) String() string

+ type VarSet map[Var]struct

+ func NewVarSet(vs ...Var) VarSet

+ func Unify(safe VarSet, a *Term, b *Term) VarSet

+ func (s VarSet) Add(v Var)

+ func (s VarSet) Contains(v Var) bool

+ func (s VarSet) Copy() VarSet

+ func (s VarSet) Diff(vs VarSet) VarSet

+ func (s VarSet) Intersect(vs VarSet) VarSet

+ func (s VarSet) String() string

+ func (s VarSet) Update(vs VarSet)

+ type Visitor interface

+ Visit func(v interface{}) (w Visitor)

v0.1.0-rc3

Jun 23, 2016

v0.1.0-rc2

Jun 7, 2016

v0.1.0-rc1

Jun 3, 2016

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL