symbols

var (
	// MatchPrefix matches name constants that have a given prefix.
	MatchPrefix = ast.PredicateSym{":match_prefix", 2}

	// StartsWith matches string constants that have a given prefix.
	StartsWith = ast.PredicateSym{":string:starts_with", 2}

	// EndsWith matches string constants that have a given suffix.
	EndsWith = ast.PredicateSym{":string:ends_with", 2}

	// Contains matches string constants that contain the given string.
	Contains = ast.PredicateSym{":string:contains", 2}

	// Filter is turning a boolean function into a predicate.
	Filter = ast.PredicateSym{":filter", 1}

	// Lt is the less-than relation on numbers.
	Lt = ast.PredicateSym{":lt", 2}

	// Le is the less-than-or-equal relation on numbers.
	Le = ast.PredicateSym{":le", 2}

	// Gt is the greater-than relation on numbers.
	Gt = ast.PredicateSym{":gt", 2}

	// Ge is the greater-than-or-equal relation on numbers.
	Ge = ast.PredicateSym{":ge", 2}

	// MatchPair mode(+, -, -) matches a pair to its elements.
	MatchPair = ast.PredicateSym{":match_pair", 3}

	// MatchCons mode(+, -, -) matches a list to head and tail.
	MatchCons = ast.PredicateSym{":match_cons", 3}

	// MatchNil matches the empty list.
	MatchNil = ast.PredicateSym{":match_nil", 1}

	// MatchEntry mode(+, +, -) matches an entry in a map.
	MatchEntry = ast.PredicateSym{":match_entry", 3}

	// MatchField mode(+, +, -) matches a field in a struct.
	MatchField = ast.PredicateSym{":match_field", 3}

	// ListMember mode(+, -) either checks membership or binds var to every element.
	ListMember = ast.PredicateSym{":list:member", 2}

	// WithinDistance is a relation on numbers X, Y, Z satisfying |X - Y| < Z.
	WithinDistance = ast.PredicateSym{":within_distance", 3}

	// Div is a family of functions mapping integer division: X,Y1,.. to (X / Y1) / Y2 ... DIV(X) is 1/x.
	Div = ast.FunctionSym{"fn:div", -1}
	// FloatDiv is a family of functions mapping division: X,Y1,.. to (X / Y1) / Y2 ... FloatDiv(X) is 1/x.
	FloatDiv = ast.FunctionSym{"fn:float:div", -1}
	// FloatMult is a family of functions mapping multiplication: X,Y1,.. to (X * Y1) * Y2 ... FloatMult(x) is x.
	FloatMult = ast.FunctionSym{"fn:float:mult", -1}
	// FloatPlus is a family of functions mapping addition: X,Y1,.. to (X + Y1) + Y2 ... FloatPlus(x) is x.
	FloatPlus = ast.FunctionSym{"fn:float:plus", -1}
	// Mult is a family of functions mapping X,Y1,.. to (X * Y1) * Y2 ... MULT(x) is x.
	Mult = ast.FunctionSym{"fn:mult", -1}
	// Plus is a family of functions mapping X,Y1,.. to (X + Y1) + Y2 ... PLUS(x) is x.
	Plus = ast.FunctionSym{"fn:plus", -1}
	// Minus is a family of functions mapping X,Y1,.. to (X - Y1) - Y2 ...MINUS(x) is -X.
	Minus = ast.FunctionSym{"fn:minus", -1}
	// Sqrt returns the square root of a numeric argument.
	Sqrt = ast.FunctionSym{"fn:sqrt", 1}

	// Collect turns a collection { tuple_1,...tuple_n } into a list [tuple_1, ..., tuple_n].
	Collect = ast.FunctionSym{"fn:collect", -1}
	// CollectDistinct turns a collection { tuple_1,...tuple_n } into a list with distinct elements [tuple_1, ..., tuple_n].
	CollectDistinct = ast.FunctionSym{"fn:collect_distinct", -1}
	// PickAny reduces a set { x_1,...x_n } to a single { x_i },
	PickAny = ast.FunctionSym{"fn:pick_any", 1}
	// Max reduces a set { x_1,...x_n } to { x_i } that is maximal.
	Max = ast.FunctionSym{"fn:max", 1}
	// FloatMax reduces a set of float64 { x_1,...x_n } to { x_i } that is maximal.
	FloatMax = ast.FunctionSym{"fn:float:max", 1}
	// Min reduces a set { x_1,...x_n } to { x_i } that is minimal.
	Min = ast.FunctionSym{"fn:min", 1}
	// FloatMin reduces a set of float64 { x_1,...x_n } to { x_i } that is minimal.
	FloatMin = ast.FunctionSym{"fn:float:min", 1}
	// Sum reduces a set { x_1,...x_n } to { x_1 + ... + x_n }.
	Sum = ast.FunctionSym{"fn:sum", 1}
	// FloatSum reduces a set of float64 { x_1,...x_n } to { x_1 + ... + x_n }.
	FloatSum = ast.FunctionSym{"fn:float:sum", 1}
	// Count reduces a set { x_1,...x_n } to { n }.
	Count = ast.FunctionSym{"fn:count", 0}
	// CountDistinct reduces a set { x_1,...x_n } to { m } with m being the
	// number of unique elements.
	CountDistinct = ast.FunctionSym{"fn:count_distinct", 0}
	// Avg reduces a set { x_1,...x_n } to { fn:sum(x_1,...,x_n) /  n }.
	Avg = ast.FunctionSym{"fn:avg", 1}

	// GroupBy groups all tuples by the values of key variables, e.g. 'group_by(X)'.
	// An empty group_by() treats the whole relation as a group.
	GroupBy = ast.FunctionSym{"fn:group_by", -1}

	// Append appends a element to a list.
	Append = ast.FunctionSym{"fn:list:append", 2}

	// ListGet is a function (List, Number) which returns element at index 'Number'.
	ListGet = ast.FunctionSym{"fn:list:get", 2}

	// ListContains is a function (List, Member) which returns /true if Member is contained in list.
	ListContains = ast.FunctionSym{"fn:list:contains", 2}

	// Len returns length of a list.
	Len = ast.FunctionSym{"fn:list:len", 1}
	// Cons constructs a pair.
	Cons = ast.FunctionSym{"fn:list:cons", 2}
	// Pair constructs a pair.
	Pair = ast.FunctionSym{"fn:pair", 2}
	// MapGet is a function (Map, Key) which returns element at key.
	MapGet = ast.FunctionSym{"fn:map:get", 2}
	// StructGet is a function (Struct, Field) which returns specified field.
	StructGet = ast.FunctionSym{"fn:struct:get", 2}
	// Tuple acts either as identity (one argument), pair (two arguments) or nested pair (more).
	Tuple = ast.FunctionSym{"fn:tuple", -1}
	// Some constructs an element of an option type.
	Some = ast.FunctionSym{"fn:some", 1}
	// List constructs a list.
	List = ast.FunctionSym{"fn:list", -1}
	// Map constructs a map.
	Map = ast.FunctionSym{"fn:map", -1}
	// Struct constructs a struct.
	Struct = ast.FunctionSym{"fn:struct", -1}

	// FunType is a constructor for a function type.
	// fn:Fun(Res, Arg1, ..., ArgN) is Res <= Arg1, ..., ArgN
	FunType = ast.FunctionSym{"fn:Fun", -1}
	// RelType is a constructor for a relation type.
	RelType = ast.FunctionSym{"fn:Rel", -1}
	// SingletonType is a constructor for a singleton type.
	SingletonType = ast.FunctionSym{"fn:Singleton", 1}
	// NumberToString converts from ast.NumberType to ast.StringType
	NumberToString = ast.FunctionSym{"fn:number:to_string", 1}
	// Float64ToString converts from ast.Float64Type to ast.StringType
	Float64ToString = ast.FunctionSym{"fn:float64:to_string", 1}
	// NameToString converts from ast.NameType to ast.StringType
	NameToString = ast.FunctionSym{"fn:name:to_string", 1}
	// NameRoot returns the first name part of a name.
	NameRoot = ast.FunctionSym{"fn:name:root", 1}
	// NameTip returns the last name part of a name.
	NameTip = ast.FunctionSym{"fn:name:tip", 1}
	// NameList turns a name into a list of name parts.
	NameList = ast.FunctionSym{"fn:name:list", 1}
	// StringConcatenate concatenates the arguments into a single string constant.
	StringConcatenate = ast.FunctionSym{"fn:string:concat", -1}
	// StringReplace replaces old with new in the first n occurrences of a string.
	StringReplace = ast.FunctionSym{"fn:string:replace", 4}
	// PairType is a constructor for a pair type.
	PairType = ast.FunctionSym{"fn:Pair", 2}
	// TupleType is a type-level function that returns a tuple type out of pair types.
	TupleType = ast.FunctionSym{"fn:Tuple", -1}
	// OptionType is a constructor for an option type.
	// A value of fn:Option(T) is either fn:some(c) for c:T, or fn:none().
	// TODO: Implement runtime representation.
	OptionType = ast.FunctionSym{"fn:Option", 1}
	// ListType is a constructor for a list type.
	ListType = ast.FunctionSym{"fn:List", 1}
	// MapType is a constructor for a map type.
	MapType = ast.FunctionSym{"fn:Map", 2}
	// StructType is a constructor for a struct type.
	StructType = ast.FunctionSym{"fn:Struct", -1}
	// UnionType is a constructor for a union type.
	UnionType = ast.FunctionSym{"fn:Union", -1}

	// Optional may appear inside StructType to indicate optional fields.
	Optional = ast.FunctionSym{"fn:opt", -1}

	// Package is an improper symbol, used to represent package declaration.
	Package = ast.PredicateSym{"Package", 0}
	// Use is an improper symbol, used to represent use declaration.
	Use = ast.PredicateSym{"Use", 0}

	// TypeConstructors is a list of function symbols used in structured type expressions.
	// Each name is mapped to the corresponding type constructor (a function at the level of types).
	TypeConstructors = map[string]ast.FunctionSym{
		UnionType.Symbol:     UnionType,
		SingletonType.Symbol: SingletonType,
		ListType.Symbol:      ListType,
		OptionType.Symbol:    OptionType,
		PairType.Symbol:      PairType,
		TupleType.Symbol:     TupleType,
		MapType.Symbol:       MapType,
		StructType.Symbol:    StructType,
		FunType.Symbol:       FunType,
		RelType.Symbol:       RelType,
	}

	// EmptyType is a type without members.
	// TODO: replace with /bot
	EmptyType = ast.ApplyFn{UnionType, nil}

	// BuiltinRelations maps each builtin predicate to its argument range list
	BuiltinRelations = map[ast.PredicateSym]ast.BaseTerm{
		MatchPrefix: NewRelType(ast.NameBound, ast.NameBound),
		StartsWith:  NewRelType(ast.StringBound, ast.StringBound),
		EndsWith:    NewRelType(ast.StringBound, ast.StringBound),
		Contains:    NewRelType(ast.StringBound, ast.StringBound),
		Filter:      NewRelType(BoolType()),

		Lt:       NewRelType(ast.NumberBound, ast.NumberBound),
		Le:       NewRelType(ast.NumberBound, ast.NumberBound),
		Gt:       NewRelType(ast.NumberBound, ast.NumberBound),
		Ge:       NewRelType(ast.NumberBound, ast.NumberBound),
		MatchNil: NewRelType(NewListType(ast.Variable{"X"})),
		MatchCons: NewRelType(
			NewListType(ast.Variable{"X"}), ast.Variable{"X"}, NewListType(ast.Variable{"X"})),
		MatchPair: NewRelType(
			NewPairType(ast.Variable{"X"}, ast.Variable{"Y"}), ast.Variable{"X"}, ast.Variable{"Y"}),
		MatchEntry: NewRelType(
			NewMapType(ast.AnyBound, ast.AnyBound), ast.AnyBound),

		MatchField: NewRelType(
			ast.AnyBound, ast.NameBound, ast.AnyBound),
		ListMember: NewRelType(ast.Variable{"X"}, NewListType(ast.Variable{"X"})),
	}
)