ast

Apr 30, 2018

Changes in this version

+ var URLQueryDecode = &Builtin

+ var URLQueryEncode = &Builtin

Apr 11, 2018

Changes in this version

+ var Base64Decode = &Builtin

+ var Base64Encode = &Builtin

+ var CryptoX509ParseCertificates = &Builtin

+ var IgnoreDuringPartialEval = []*Builtin

+ var JWTVerifyRS256 = &Builtin

+ var Rem = &Builtin

+ var Trace = &Builtin

type Location

+ func (loc *Location) Compare(other *Location) int

Feb 22, 2018

Changes in this version

+ var Assign = &Builtin

+ var Clock = &Builtin

+ var Date = &Builtin

+ var Equal = &Builtin

+ var GlobsMatch = &Builtin

+ var HTTPSend = &Builtin

+ var Intersection = &Builtin

+ var Union = &Builtin

+ func Pretty(w io.Writer, x interface{})

+ func TransformVars(x interface{}, f func(Var) (Value, error)) (interface{}, error)

+ func WalkBeforeAndAfter(v BeforeAndAfterVisitor, x interface{})

+ func WalkTerms(x interface{}, f func(*Term) bool)

+ type BeforeAndAfterVisitor interface

+ After func(x interface{})

+ Before func(x interface{})

type Builtin

+ Relation bool

+ func (b *Builtin) Call(operands ...*Term) *Term

+ type Call []*Term

+ func (c Call) Compare(other Value) int

+ func (c Call) Copy() Call

+ func (c Call) Find(Ref) (Value, error)

+ func (c Call) Hash() int

+ func (c Call) IsGround() bool

+ func (c Call) MakeExpr(output *Term) *Expr

+ func (c Call) String() string

type Compiler

+ func (c *Compiler) GetArity(ref Ref) int

type Expr

+ func (expr *Expr) IsAssignment() bool

+ func (expr *Expr) SetOperator(term *Term) *Expr

type QueryCompiler

+ RewrittenVars func() map[Var]Var

+ WithStageAfter func(after string, stage QueryCompilerStage) QueryCompiler

+ type QueryCompilerStage func(QueryCompiler, Body) (Body, error)

type Rule

+ func ParseRuleFromCallEqExpr(module *Module, lhs, rhs *Term) (*Rule, error)

type Term

+ func CallTerm(terms ...*Term) *Term

+ func (term *Term) Get(name *Term) *Term

type With

+ func (w *With) SetLocation(loc *Location) *With

Jan 18, 2018

Changes in this version

+ var IsArray = &Builtin

+ var IsBoolean = &Builtin

+ var IsNull = &Builtin

+ var IsNumber = &Builtin

+ var IsObject = &Builtin

+ var IsSet = &Builtin

+ var IsString = &Builtin

+ var Sort = &Builtin

+ var TypeNameBuiltin = &Builtin

type Array

+ func (arr Array) Sorted() Array

type Body

+ func (body Body) Set(expr *Expr, pos int)

+ type Cloner interface

+ Clone func() interface{}

type Object

+ func NewObject(t ...[2]*Term) Object

+ Foreach func(func(*Term, *Term))

+ Insert func(*Term, *Term)

+ Iter func(func(*Term, *Term) error) error

+ Len func() int

+ Map func(func(*Term, *Term) (*Term, *Term, error)) (Object, error)

+ Until func(func(*Term, *Term) bool) bool

type Option

+ func AllowInvalidUTF8(b bool) Option

+ func Entrypoint(ruleName string) Option

+ func InitState(key string, value interface{}) Option

+ func MaxExpressions(maxExprCnt uint64) Option

+ func Statistics(stats *Stats, choiceNoMatch string) Option

type Ref

+ func (ref Ref) Insert(x *Term, pos int) Ref

type Set

+ func NewSet(t ...*Term) Set

+ Foreach func(func(*Term))

+ Len func() int

+ Sorted func() Array

+ Until func(func(*Term) bool) bool

+ type Stats struct

+ ChoiceAltCnt map[string]map[string]int

+ ExprCnt uint64

Nov 15, 2017

Changes in this version

+ func IsComprehension(x Value) bool

type Expr

+ Generated bool

type GenericTransformer

+ func NewGenericTransformer(f func(x interface{}) (interface{}, error)) *GenericTransformer

type Var

+ func (v Var) IsGenerated() bool

Oct 30, 2017

Changes in this version

+ var ParseDurationNanos = &Builtin

+ var Product = &Builtin

Oct 10, 2017

Changes in this version

type Args

+ func (a Args) Vars() VarSet

type Builtin

+ Decl *types.Function

+ func (b *Builtin) Ref() Ref

type Expr

+ Infix bool

+ func (expr *Expr) IsCall() bool

+ func (expr *Expr) Operator() Ref

type Head

+ Args Args

type Rule

+ func ParseRuleFromCallExpr(module *Module, terms []*Term) (*Rule, error)

type VarVisitorParams

+ SkipRefCallHead bool

Sep 15, 2017

Changes in this version

+ func ContainsComprehensions(v interface{}) bool

+ func ContainsRefs(v interface{}) bool

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

Aug 29, 2017

Changes in this version

+ var WalkBuiltin = &Builtin

type Expr

+ func (expr *Expr) SetLocation(loc *Location) *Expr

type Rule

+ func ParseCompleteDocRuleFromEqExpr(module *Module, lhs, rhs *Term) (*Rule, error)

+ func ParsePartialObjectDocRuleFromEqExpr(module *Module, lhs, rhs *Term) (*Rule, error)

+ func ParsePartialSetDocRuleFromTerm(module *Module, term *Term) (*Rule, error)

+ func ParseRuleFromExpr(module *Module, expr *Expr) (*Rule, error)

Jul 24, 2017

Changes in this version

+ const CompileErrorLimitDefault

type Compiler

+ func (c *Compiler) SetErrorLimit(limit int) *Compiler

type Ref

+ func (ref Ref) ConstantPrefix() Ref

Jul 17, 2017

Changes in this version

+ type ObjectComprehension struct

+ Body Body

+ Key *Term

+ Value *Term

+ func (oc *ObjectComprehension) Compare(other Value) int

+ func (oc *ObjectComprehension) Copy() *ObjectComprehension

+ func (oc *ObjectComprehension) Equal(other Value) bool

+ func (oc *ObjectComprehension) Find(path Ref) (Value, error)

+ func (oc *ObjectComprehension) Hash() int

+ func (oc *ObjectComprehension) IsGround() bool

+ func (oc *ObjectComprehension) String() string

+ type RefErrInvalidDetail struct

+ Have types.Type

+ OneOf []Value

+ Pos int

+ Ref Ref

+ Want types.Type

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

+ type RefErrMissingDetail struct

+ Ref Ref

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

+ type RefErrUnsupportedDetail struct

+ Have types.Type

+ Pos int

+ Ref Ref

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

+ type SetComprehension struct

+ Body Body

+ Term *Term

+ func (sc *SetComprehension) Compare(other Value) int

+ func (sc *SetComprehension) Copy() *SetComprehension

+ func (sc *SetComprehension) Equal(other Value) bool

+ func (sc *SetComprehension) Find(path Ref) (Value, error)

+ func (sc *SetComprehension) Hash() int

+ func (sc *SetComprehension) IsGround() bool

+ func (sc *SetComprehension) String() string

type Term

+ func ObjectComprehensionTerm(key, value *Term, body Body) *Term

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

Jul 5, 2017

Changes in this version

+ const ArgsTypeName

+ const FuncHeadTypeName

+ const FuncTypeName

+ var NowNanos = &Builtin

+ var ParseNanos = &Builtin

+ var ParseRFC3339Nanos = &Builtin

+ var YAMLMarshal = &Builtin

+ var YAMLUnmarshal = &Builtin

+ func WalkFuncs(x interface{}, f func(*Func) bool)

+ type Args []*Term

+ func (a Args) Copy() Args

+ func (a Args) String() string

type Array

+ func (arr Array) Compare(other Value) int

type ArrayComprehension

+ func (ac *ArrayComprehension) Compare(other Value) int

type Boolean

+ func (bol Boolean) Compare(other Value) int

type Compiler

+ FuncMap map[String][]*Func

+ FuncTree *TreeNode

+ Graph *Graph

+ func (c *Compiler) GetAllFuncs() map[String][]*Func

+ func (c *Compiler) GetFunc(name String) []*Func

type Expr

+ func (expr *Expr) Name() String

+ type Func struct

+ Body Body

+ Head *FuncHead

+ Location *Location

+ Module *Module

+ func (f *Func) Compare(other *Func) int

+ func (f *Func) Copy() *Func

+ func (f *Func) Equal(other *Func) bool

+ func (f *Func) Loc() *Location

+ func (f *Func) Path() Ref

+ func (f *Func) PathString() String

+ func (f *Func) String() string

+ type FuncHead struct

+ Args Args

+ Location *Location

+ Name Var

+ Output *Term

+ func NewFuncHead(name Var, out *Term, args ...*Term) *FuncHead

+ func (h *FuncHead) ArgVars() VarSet

+ func (h *FuncHead) Compare(other *FuncHead) int

+ func (h *FuncHead) Copy() *FuncHead

+ func (h *FuncHead) Equal(other *FuncHead) bool

+ func (h *FuncHead) Loc() *Location

+ func (h *FuncHead) OutVars() VarSet

+ func (h *FuncHead) String() string

+ func (h *FuncHead) Vars() VarSet

+ type Graph struct

+ func NewGraph(modules map[string]*Module, list func(Ref) []*Rule, ...) *Graph

+ func (g *Graph) Dependencies(x util.T) map[util.T]struct{}

+ func (g *Graph) Sort() (sorted []util.T, ok bool)

type Location

+ func (loc *Location) Equal(other *Location) bool

type Module

+ Comments []*Comment

+ Funcs []*Func

type Null

+ func (null Null) Compare(other Value) int

type Number

+ func (num Number) Compare(other Value) int

type Object

+ func (obj Object) Compare(other Value) int

type Option

+ func CommentsOption() Option

+ func GlobalStore(key string, value interface{}) Option

type Ref

+ func (ref Ref) Compare(other Value) int

type Set

+ func (s *Set) Compare(other Value) int

type String

+ func (str String) Compare(other Value) int

type Term

+ func (term *Term) SetLocation(loc *Location) *Term

+ type TreeNode struct

+ Children map[Value]*TreeNode

+ Hide bool

+ Key Value

+ Values []util.T

+ func NewFuncTree(mtree *ModuleTreeNode) *TreeNode

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

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

+ func (n *TreeNode) Size() int

type TypeEnv

+ func (env *TypeEnv) GetFunc(name String) []types.Type

+ func (env *TypeEnv) PutFunc(name String, args []types.Type)

type Value

+ Compare func(other Value) int

type Var

+ func (v Var) Compare(other Value) int

type VarVisitorParams

+ SkipFuncVars bool

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

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)

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)

Feb 14, 2017

Changes in this version

+ var RootDocumentNames = &Set

+ var RootDocumentRefs = &Set

type RuleTreeNode

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

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

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

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)

Dec 23, 2016

Changes in this version

type VarVisitorParams

+ SkipBuiltinOperators bool

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

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

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

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

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)