builtin

Documentation

Overview

Package builtin contains functions for evaluating built-in predicates.

Index

• Variables
• func Decide(atom ast.Atom, subst *unionfind.UnionFind) (bool, []*unionfind.UnionFind, error)
• func GetBuiltinFunctionType(sym ast.FunctionSym) (ast.BaseTerm, bool)
• func IsBuiltinFunction(sym ast.FunctionSym) bool
• func IsReducerFunction(sym ast.FunctionSym) bool
• type TypeChecker
  • func NewTypeChecker(decls map[ast.PredicateSym]ast.Decl) (*TypeChecker, error)
  • func NewTypeCheckerFromDesugared(decls map[ast.PredicateSym]*ast.Decl) *TypeChecker
  • func (t TypeChecker) CheckOneBoundDecl(fact ast.Atom, boundDecl ast.BoundDecl) error
  • func (t TypeChecker) CheckTypeBounds(fact ast.Atom) error

Variables

var (
	// Predicates has all built-in predicates.
	Predicates = map[ast.PredicateSym]ast.Mode{
		symbols.MatchPrefix:    {ast.ArgModeInput, ast.ArgModeInput},
		symbols.StartsWith:     {ast.ArgModeInput, ast.ArgModeInput},
		symbols.EndsWith:       {ast.ArgModeInput, ast.ArgModeInput},
		symbols.Contains:       {ast.ArgModeInput, ast.ArgModeInput},
		symbols.Filter:         {ast.ArgModeInput},
		symbols.Lt:             {ast.ArgModeInput, ast.ArgModeInput},
		symbols.Le:             {ast.ArgModeInput, ast.ArgModeInput},
		symbols.Gt:             {ast.ArgModeInput, ast.ArgModeInput},
		symbols.Ge:             {ast.ArgModeInput, ast.ArgModeInput},
		symbols.ListMember:     {ast.ArgModeOutput, ast.ArgModeInput},
		symbols.WithinDistance: {ast.ArgModeInput, ast.ArgModeInput, ast.ArgModeInput},
		symbols.MatchPair:      {ast.ArgModeInput, ast.ArgModeOutput, ast.ArgModeOutput},
		symbols.MatchCons:      {ast.ArgModeInput, ast.ArgModeOutput, ast.ArgModeOutput},
		symbols.MatchNil:       {ast.ArgModeInput},
		symbols.MatchField:     {ast.ArgModeInput, ast.ArgModeInput, ast.ArgModeOutput},
		symbols.MatchEntry:     {ast.ArgModeInput, ast.ArgModeInput, ast.ArgModeOutput},
	}

	// Functions has all built-in functions.
	Functions = map[ast.FunctionSym]ast.BaseTerm{
		symbols.Div:      emptyType,
		symbols.FloatDiv: emptyType,
		symbols.Mult:     emptyType,
		symbols.Plus:     emptyType,
		symbols.Minus:    emptyType,

		symbols.GroupBy: emptyType,

		symbols.ListGet:      symbols.NewFunType(symbols.NewOptionType(varX), listOfX, ast.NumberBound),
		symbols.ListContains: symbols.NewFunType(symbols.BoolType(), listOfX, varX),
		symbols.Append:       symbols.NewFunType(listOfX, listOfX, varX),
		symbols.Cons:         symbols.NewFunType(listOfX, varX, listOfX),
		symbols.Len:          symbols.NewFunType(ast.NumberBound, listOfX),
		symbols.Pair:         symbols.NewFunType(symbols.NewPairType(varX, varY), varX, varY),
		symbols.Some:         symbols.NewFunType(symbols.NewOptionType(varX), varX),
		symbols.StringConcatenate: symbols.NewFunType(
			ast.StringBound, ast.AnyBound),
		symbols.StructGet:       symbols.NewFunType(ast.AnyBound, ast.AnyBound, ast.NameBound),
		symbols.NumberToString:  symbols.NewFunType(ast.StringBound, ast.NumberBound),
		symbols.Float64ToString: symbols.NewFunType(ast.StringBound, ast.Float64Bound),
		symbols.NameToString:    symbols.NewFunType(ast.StringBound, ast.NameBound),

		symbols.List:   symbols.NewFunType(symbols.NewListType(varX), varX),
		symbols.Map:    emptyType,
		symbols.Tuple:  emptyType,
		symbols.Struct: emptyType,
	}

	// ReducerFunctions has those built-in functions with are reducers.
	ReducerFunctions = map[ast.FunctionSym]ast.BaseTerm{
		symbols.Collect:         symbols.NewFunType(listOfX, listOfX),
		symbols.CollectDistinct: symbols.NewFunType(listOfX, listOfX),
		symbols.PickAny:         symbols.NewFunType(varX, listOfX),
		symbols.Max:             symbols.NewFunType(ast.NumberBound, listOfNum),
		symbols.Min:             symbols.NewFunType(ast.NumberBound, listOfNum),
		symbols.Sum:             symbols.NewFunType(ast.NumberBound, listOfNum),
		symbols.FloatMax:        symbols.NewFunType(ast.Float64Bound, listOfFloats),
		symbols.FloatMin:        symbols.NewFunType(ast.Float64Bound, listOfFloats),
		symbols.FloatSum:        symbols.NewFunType(ast.Float64Bound, listOfFloats),
		symbols.Count:           symbols.NewFunType(ast.NumberBound, listOfX),
	}
)

Functions

func Decide

func Decide(atom ast.Atom, subst *unionfind.UnionFind) (bool, []*unionfind.UnionFind, error)

Decide evaluates an atom of a built-in predicate. The atom must no longer contain any apply-expressions or variables.

func GetBuiltinFunctionType

func GetBuiltinFunctionType(sym ast.FunctionSym) (ast.BaseTerm, bool)

GetBuiltinFunctionType returns the type of a builtin function. The type may contain type variables.

func IsBuiltinFunction

func IsBuiltinFunction(sym ast.FunctionSym) bool

IsBuiltinFunction returns true if sym is a builtin function.

func IsReducerFunction

func IsReducerFunction(sym ast.FunctionSym) bool

IsReducerFunction returns true if sym is a reducer function.

Types

type TypeChecker

type TypeChecker struct {
	// contains filtered or unexported fields
}

TypeChecker checks the type of constant (run-time type).

func NewTypeChecker

func NewTypeChecker(decls map[ast.PredicateSym]ast.Decl) (*TypeChecker, error)

NewTypeChecker returns a new TypeChecker. The decls must be desugared so they only contain type bounds.

func NewTypeCheckerFromDesugared

func NewTypeCheckerFromDesugared(decls map[ast.PredicateSym]*ast.Decl) *TypeChecker

NewTypeCheckerFromDesugared returns a new TypeChecker. The declarations must be in desugared form.

func (TypeChecker) CheckOneBoundDecl

func (t TypeChecker) CheckOneBoundDecl(fact ast.Atom, boundDecl ast.BoundDecl) error

CheckOneBoundDecl checks whether a fact is consistent with a given type bounds tuple.

func (TypeChecker) CheckTypeBounds

func (t TypeChecker) CheckTypeBounds(fact ast.Atom) error

CheckTypeBounds checks whether there fact is consistent with at least one of the bound decls.