engine

Feb 11, 2023

Changes in this version

+ func CompareAtomic(a T, t Term, cmp func(T, T) int, env *Env) int

+ func CompareCompound(c Compound, t Term, env *Env) int

+ func WriteCompound(w io.Writer, c Compound, opts *WriteOptions, env *Env) error

Dec 31, 2022

Changes in this version

type Promise

+ func Negate(vm *VM, goal Term, k Cont, env *Env) *Promise

Dec 11, 2022

Changes in this version

+ type Cont func(*Env) *Promise

type Promise

+ func PutChar(vm *VM, streamOrAlias, char Term, k Cont, env *Env) *Promise

Nov 27, 2022

Changes in this version

type ListIterator

+ AllowCycle bool

type Parser

+ Vars []ParsedVariable

+ func (p *Parser) SetPlaceholder(placeholder Atom, args ...interface{}) error

+ type Predicate0 func(*VM, func(*Env) *Promise, *Env) *Promise

+ type Predicate1 func(*VM, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate2 func(*VM, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate3 func(*VM, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate4 func(*VM, Term, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate5 func(*VM, Term, Term, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate6 func(*VM, Term, Term, Term, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate7 func(*VM, Term, Term, Term, Term, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

+ type Predicate8 func(*VM, Term, Term, Term, Term, Term, Term, Term, Term, func(*Env) *Promise, *Env) *Promise

type Promise

+ func Abolish(vm *VM, pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func Asserta(vm *VM, t Term, k func(*Env) *Promise, env *Env) *Promise

+ func Assertz(vm *VM, t Term, k func(*Env) *Promise, env *Env) *Promise

+ func BagOf(vm *VM, template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call(vm *VM, goal Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call1(vm *VM, closure, arg1 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call2(vm *VM, closure, arg1, arg2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call3(vm *VM, closure, arg1, arg2, arg3 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call4(vm *VM, closure, arg1, arg2, arg3, arg4 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Call5(vm *VM, closure, arg1, arg2, arg3, arg4, arg5 Term, k func(*Env) *Promise, ...) *Promise

+ func Call6(vm *VM, closure, arg1, arg2, arg3, arg4, arg5, arg6 Term, ...) *Promise

+ func Call7(vm *VM, closure, arg1, arg2, arg3, arg4, arg5, arg6, arg7 Term, ...) *Promise

+ func CallNth(vm *VM, goal, nth Term, k func(*Env) *Promise, env *Env) *Promise

+ func CharConversion(vm *VM, inChar, outChar Term, k func(*Env) *Promise, env *Env) *Promise

+ func Clause(vm *VM, head, body Term, k func(*Env) *Promise, env *Env) *Promise

+ func Close(vm *VM, streamOrAlias, options Term, k func(*Env) *Promise, env *Env) *Promise

+ func Consult(vm *VM, files Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentCharConversion(vm *VM, inChar, outChar Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentInput(vm *VM, stream Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentOp(vm *VM, priority, specifier, op Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentOutput(vm *VM, stream Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentPredicate(vm *VM, pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func CurrentPrologFlag(vm *VM, flag, value Term, k func(*Env) *Promise, env *Env) *Promise

+ func Equal(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func ExpandTerm(vm *VM, term1, term2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func FindAll(vm *VM, template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func FlushOutput(vm *VM, streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func GetByte(vm *VM, streamOrAlias, inByte Term, k func(*Env) *Promise, env *Env) *Promise

+ func GetChar(vm *VM, streamOrAlias, char Term, k func(*Env) *Promise, env *Env) *Promise

+ func GreaterThan(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func GreaterThanOrEqual(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Is(vm *VM, result, expression Term, k func(*Env) *Promise, env *Env) *Promise

+ func LessThan(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func LessThanOrEqual(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Negation(vm *VM, goal Term, k func(*Env) *Promise, env *Env) *Promise

+ func NotEqual(_ *VM, e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func Op(vm *VM, priority, specifier, op Term, k func(*Env) *Promise, env *Env) *Promise

+ func PeekByte(vm *VM, streamOrAlias, inByte Term, k func(*Env) *Promise, env *Env) *Promise

+ func PeekChar(vm *VM, streamOrAlias, char Term, k func(*Env) *Promise, env *Env) *Promise

+ func Phrase(vm *VM, grBody, s0, s Term, k func(*Env) *Promise, env *Env) *Promise

+ func PutByte(vm *VM, streamOrAlias, byt Term, k func(*Env) *Promise, env *Env) *Promise

+ func PutCode(vm *VM, streamOrAlias, code Term, k func(*Env) *Promise, env *Env) *Promise

+ func ReadTerm(vm *VM, streamOrAlias, out, options Term, k func(*Env) *Promise, env *Env) *Promise

+ func Retract(vm *VM, t Term, k func(*Env) *Promise, env *Env) *Promise

+ func SetInput(vm *VM, streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func SetOf(vm *VM, template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func SetOutput(vm *VM, streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func SetPrologFlag(vm *VM, flag, value Term, k func(*Env) *Promise, env *Env) *Promise

+ func SetStreamPosition(vm *VM, streamOrAlias, position Term, k func(*Env) *Promise, env *Env) *Promise

+ func StreamProperty(vm *VM, stream, property Term, k func(*Env) *Promise, env *Env) *Promise

type Stream

+ func NewInputBinaryStream(r io.Reader) *Stream

+ func NewInputTextStream(r io.Reader) *Stream

+ func NewOutputBinaryStream(w io.Writer) *Stream

+ func NewOutputTextStream(w io.Writer) *Stream

+ func (s *Stream) Flush() error

+ func (s *Stream) Name() string

+ func (s *Stream) ReadByte() (byte, error)

+ func (s *Stream) ReadRune() (r rune, size int, err error)

+ func (s *Stream) Seek(offset int64, whence int) (int64, error)

+ func (s *Stream) UnreadByte() error

+ func (s *Stream) UnreadRune() error

+ func (s *Stream) Write(p []byte) (int, error)

+ func (s *Stream) WriteByte(c byte) error

+ func (s *Stream) WriteRune(r rune) (size int, err error)

+ func (s *Stream) WriteString(str string) (int, error)

type Term

+ func PartialList(tail Term, ts ...Term) Term

type VM

+ FS fs.FS

+ Unknown func(name Atom, args []Term, env *Env)

+ func (vm *VM) Compile(ctx context.Context, s string, args ...interface{}) error

Oct 30, 2022

Changes in this version

type Atom

+ func NewAtom(name string) Atom

+ func (a Atom) GoString() string

type Variable

+ func NewNamedVariable(name string) Variable

+ func (v Variable) Anonymous() bool

Oct 16, 2022

Changes in this version

+ type DiscontiguousError struct

+ PI ProcedureIndicator

+ func (e *DiscontiguousError) Error() string

type ProcedureIndicator

+ func PI(t Term, env *Env) (ProcedureIndicator, func(int) Term, error)

type State

+ FS fs.FS

+ func (state *State) Compile(ctx context.Context, s string, args ...interface{}) error

+ func (state *State) Consult(files Term, k func(*Env) *Promise, env *Env) *Promise

Aug 28, 2022

Changes in this version

+ func WriteTerm(w io.Writer, t Term, opts *WriteOptions, env *Env) error

type Compound

+ Arg func(n int) Term

+ Arity func() int

type Env

+ var GoStringEnv *Env

+ func (e *Env) Compare(x, y Term) Order

+ func (e *Env) Unify(x, y Term, occursCheck bool) (*Env, bool)

+ type Order int8

+ const OrderEqual

+ const OrderGreater

+ const OrderLess

+ func (o Order) GoString() string

+ func (o Order) Term() Term

type Promise

+ func Append(xs, ys, zs Term, k func(*Env) *Promise, env *Env) *Promise

type Term

+ func CharList(s string) Term

+ func CodeList(s string) Term

+ type TermID interface

+ func ID(t Term) TermID

+ type TermIDer interface

+ TermID func() TermID

type Variable

+ func (v Variable) GoString() string

Jul 31, 2022

Changes in this version

type ListIterator

+ AllowPartial bool

Jul 16, 2022

Changes in this version

type Atom

+ func (a Atom) WriteTerm(w io.Writer, opts *WriteOptions, _ *Env) error

type Compound

+ func (c *Compound) WriteTerm(w io.Writer, opts *WriteOptions, env *Env) error

type Exception

+ func EvaluationError(ev ExceptionalValue, env *Env) Exception

+ func NewException(term Term, env *Env) Exception

+ func RepresentationError(limit Flag, env *Env) Exception

+ func ResourceError(resource Resource, env *Env) Exception

+ func SyntaxError(err error, env *Env) Exception

+ type ExceptionalValue uint8

+ const ExceptionalValueFloatOverflow

+ const ExceptionalValueIntOverflow

+ const ExceptionalValueUndefined

+ const ExceptionalValueUnderflow

+ const ExceptionalValueZeroDivisor

+ func (ev ExceptionalValue) Error() string

+ func (ev ExceptionalValue) Term() Term

+ type Flag uint8

+ const FlagCharacter

+ const FlagCharacterCode

+ const FlagInCharacterCode

+ const FlagMaxArity

+ const FlagMaxInteger

+ const FlagMinInteger

+ func (f Flag) Term() Term

type Float

+ func (f Float) WriteTerm(w io.Writer, opts *WriteOptions, _ *Env) error

type ListIterator

+ func (i *ListIterator) Suffix() Term

+ type ObjectType uint8

+ const ObjectTypeProcedure

+ const ObjectTypeSourceSink

+ const ObjectTypeStream

+ func (ot ObjectType) Term() Term

+ type Operation uint8

+ const OperationAccess

+ const OperationCreate

+ const OperationInput

+ const OperationModify

+ const OperationOpen

+ const OperationOutput

+ const OperationReposition

+ func (o Operation) Term() Term

+ type PermissionType uint8

+ const PermissionTypeBinaryStream

+ const PermissionTypeFlag

+ const PermissionTypeOperator

+ const PermissionTypePastEndOfStream

+ const PermissionTypePrivateProcedure

+ const PermissionTypeSourceSink

+ const PermissionTypeStaticProcedure

+ const PermissionTypeStream

+ const PermissionTypeTextStream

+ func (pt PermissionType) Term() Term

type Promise

+ func Length(list, length Term, k func(*Env) *Promise, env *Env) *Promise

+ func SkipMaxList(skip, max, list, suffix Term, k func(*Env) *Promise, env *Env) *Promise

+ type Resource uint8

+ const ResourceFiniteMemory

+ func (r Resource) Term() Term

type State

+ func (state *State) CallNth(goal, nth Term, k func(*Env) *Promise, env *Env) *Promise

type Stream

+ func (s *Stream) WriteTerm(w io.Writer, opts *WriteOptions, env *Env) error

type Term

+ WriteTerm func(w io.Writer, opts *WriteOptions, env *Env) error

type TokenKind

+ const TokenClose

+ const TokenCloseCurly

+ const TokenCloseList

+ const TokenCut

+ const TokenDoubleQuotedList

+ const TokenEnd

+ const TokenFloatNumber

+ const TokenInsufficient

+ const TokenLetterDigit

+ const TokenOpen

+ const TokenOpenCT

+ const TokenOpenCurly

+ const TokenOpenList

+ const TokenQuoted

+ const TokenSemicolon

+ func (k TokenKind) GoString() string

+ type ValidDomain uint8

+ const ValidDomainCharacterCodeList

+ const ValidDomainCloseOption

+ const ValidDomainFlagValue

+ const ValidDomainIOMode

+ const ValidDomainNonEmptyList

+ const ValidDomainNotLessThanZero

+ const ValidDomainOperatorPriority

+ const ValidDomainOperatorSpecifier

+ const ValidDomainOrder

+ const ValidDomainPrologFlag

+ const ValidDomainReadOption

+ const ValidDomainSourceSink

+ const ValidDomainStream

+ const ValidDomainStreamOption

+ const ValidDomainStreamOrAlias

+ const ValidDomainStreamPosition

+ const ValidDomainStreamProperty

+ const ValidDomainWriteOption

+ func (vd ValidDomain) Term() Term

+ type ValidType uint8

+ const ValidTypeAtom

+ const ValidTypeAtomic

+ const ValidTypeByte

+ const ValidTypeCallable

+ const ValidTypeCharacter

+ const ValidTypeCompound

+ const ValidTypeEvaluable

+ const ValidTypeFloat

+ const ValidTypeInByte

+ const ValidTypeInCharacter

+ const ValidTypeInteger

+ const ValidTypeList

+ const ValidTypeNumber

+ const ValidTypePair

+ const ValidTypePredicateIndicator

+ func (t ValidType) Term() Term

type Variable

+ func (v Variable) WriteTerm(w io.Writer, opts *WriteOptions, env *Env) error

+ type WriteOptions struct

+ IgnoreOps bool

+ NumberVars bool

+ Quoted bool

+ VariableNames map[Variable]Atom

Apr 2, 2022

Changes in this version

type WriteOption

+ func WithVariableNames(variableNames map[Variable]Atom) WriteOption

Mar 26, 2022

Changes in this version

+ var DefaultEvaluableFunctors = EvaluableFunctors

+ var ErrFloatOverflow = evaluationError(Atom("float_overflow"), Atom("Float overflow."))

+ var ErrInstantiation = &Exception

+ var ErrIntOverflow = evaluationError(Atom("int_overflow"), Atom("Integer overflow."))

+ var ErrUndefined = evaluationError(Atom("undefined"), Atom("Undefined."))

+ var ErrUnderflow = evaluationError(Atom("underflow"), Atom("Underflow."))

+ var ErrZeroDivisor = evaluationError(Atom("zero_divisor"), Atom("Divided by zero."))

+ type AltIterator struct

+ Alt Term

+ Env *Env

+ func (i *AltIterator) Current() Term

+ func (i *AltIterator) Next() bool

+ type AnyIterator struct

+ Any Term

+ Env *Env

+ func (i *AnyIterator) Current() Term

+ func (i *AnyIterator) Err() error

+ func (i *AnyIterator) Next() bool

type Env

+ func (e *Env) Set(ts ...Term) Term

+ type EvaluableFunctors struct

+ Binary map[Atom]func(x, y Number) (Number, error)

+ Constant map[Atom]Number

+ Unary map[Atom]func(x Number) (Number, error)

+ func (e EvaluableFunctors) Equal(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) GreaterThan(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) GreaterThanOrEqual(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) Is(result, expression Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) LessThan(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) LessThanOrEqual(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (e EvaluableFunctors) NotEqual(e1, e2 Term, k func(*Env) *Promise, env *Env) *Promise

type Exception

+ func TypeErrorAtom(culprit Term) *Exception

+ func TypeErrorAtomic(culprit Term) *Exception

+ func TypeErrorByte(culprit Term) *Exception

+ func TypeErrorCallable(culprit Term) *Exception

+ func TypeErrorCharacter(culprit Term) *Exception

+ func TypeErrorCompound(culprit Term) *Exception

+ func TypeErrorEvaluable(culprit Term) *Exception

+ func TypeErrorFloat(culprit Term) *Exception

+ func TypeErrorInByte(culprit Term) *Exception

+ func TypeErrorInCharacter(culprit Term) *Exception

+ func TypeErrorInteger(culprit Term) *Exception

+ func TypeErrorList(culprit Term) *Exception

+ func TypeErrorNumber(culprit Term) *Exception

+ func TypeErrorPair(culprit Term) *Exception

+ func TypeErrorPredicateIndicator(culprit Term) *Exception

type Lexer

+ func (l *Lexer) Token() (Token, error)

+ type ListIterator struct

+ Env *Env

+ List Term

+ func (i *ListIterator) Current() Term

+ func (i *ListIterator) Err() error

+ func (i *ListIterator) Next() bool

+ type Number interface

+ func Abs(x Number) (Number, error)

+ func Acos(x Number) (Number, error)

+ func Add(x, y Number) (Number, error)

+ func AsFloat(x Number) (Number, error)

+ func Asin(x Number) (Number, error)

+ func Atan(x Number) (Number, error)

+ func Atan2(y, x Number) (Number, error)

+ func BitwiseAnd(b1, b2 Number) (Number, error)

+ func BitwiseComplement(b1 Number) (Number, error)

+ func BitwiseLeftShift(n, s Number) (Number, error)

+ func BitwiseOr(b1, b2 Number) (Number, error)

+ func BitwiseRightShift(n, s Number) (Number, error)

+ func Ceiling(x Number) (Number, error)

+ func Cos(x Number) (Number, error)

+ func Div(x, y Number) (Number, error)

+ func Exp(x Number) (Number, error)

+ func FloatFractionalPart(x Number) (Number, error)

+ func FloatIntegerPart(x Number) (Number, error)

+ func Floor(x Number) (Number, error)

+ func IntDiv(x, y Number) (Number, error)

+ func IntFloorDiv(x, y Number) (Number, error)

+ func IntegerPower(x, y Number) (Number, error)

+ func Log(x Number) (Number, error)

+ func Max(x, y Number) (Number, error)

+ func Min(x, y Number) (Number, error)

+ func Mod(x, y Number) (Number, error)

+ func Mul(x, y Number) (Number, error)

+ func Neg(x Number) (Number, error)

+ func Pos(x Number) (Number, error)

+ func Power(x, y Number) (Number, error)

+ func Rem(x, y Number) (Number, error)

+ func Round(x Number) (Number, error)

+ func Sign(x Number) (Number, error)

+ func Sin(x Number) (Number, error)

+ func Sqrt(x Number) (Number, error)

+ func Sub(x, y Number) (Number, error)

+ func Tan(x Number) (Number, error)

+ func Truncate(x Number) (Number, error)

+ func Xor(x, y Number) (Number, error)

type Promise

+ func AcyclicTerm(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func Between(lower, upper, value Term, k func(*Env) *Promise, env *Env) *Promise

+ func KeySort(pairs, sorted Term, k func(*Env) *Promise, env *Env) *Promise

+ func Nth0(n, list, elem Term, k func(*Env) *Promise, env *Env) *Promise

+ func Nth1(n, list, elem Term, k func(*Env) *Promise, env *Env) *Promise

+ func Sort(list, sorted Term, k func(*Env) *Promise, env *Env) *Promise

+ func SubsumesTerm(general, specific Term, k func(*Env) *Promise, env *Env) *Promise

+ func Succ(x, s Term, k func(*Env) *Promise, env *Env) *Promise

+ func TermVariables(term, vars Term, k func(*Env) *Promise, env *Env) *Promise

+ type SeqIterator struct

+ Env *Env

+ Seq Term

+ func (i *SeqIterator) Current() Term

+ func (i *SeqIterator) Next() bool

type State

+ func (state *State) Assert(t Term, env *Env) error

+ func (state *State) Call1(closure, arg1 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call2(closure, arg1, arg2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call3(closure, arg1, arg2, arg3 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call4(closure, arg1, arg2, arg3, arg4 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call5(closure, arg1, arg2, arg3, arg4, arg5 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call6(closure, arg1, arg2, arg3, arg4, arg5, arg6 Term, k func(*Env) *Promise, ...) *Promise

+ func (state *State) Call7(closure, arg1, arg2, arg3, arg4, arg5, arg6, arg7 Term, k func(*Env) *Promise, ...) *Promise

+ func (state *State) Expand(term Term, env *Env) (Term, error)

+ func (state *State) Phrase(grBody, s0, s Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Write(w io.Writer, t Term, env *Env, opts ...WriteOption) error

type Term

+ func Pair(k, v Term) Term

type TokenKind

+ const TokenEOF

+ const TokenInvalid

type VM

+ func (vm *VM) Register6(name string, ...)

+ func (vm *VM) Register7(name string, ...)

+ func (vm *VM) Register8(name string, ...)

Jan 1, 2022

Changes in this version

type State

+ func (state *State) WithIgnoreOps(b bool) WriteOption

+ type WriteOption func(*writeTermOptions)

+ func WithNumberVars(b bool) WriteOption

+ func WithPriority(p int) WriteOption

+ func WithQuoted(b bool) WriteOption

Dec 31, 2021

Changes in this version

type Promise

+ func Environ(key, value Term, k func(*Env) *Promise, env *Env) *Promise

Dec 28, 2021

Changes in this version

type Atom

+ func (a Atom) Compare(t Term, env *Env) int64

type Compound

+ func (c *Compound) Compare(t Term, env *Env) int64

type EOFAction

+ func (a EOFAction) String() string

type Float

+ func (f Float) Compare(t Term, env *Env) int64

type Integer

+ func (i Integer) Compare(t Term, env *Env) int64

type Stream

+ func (s *Stream) Compare(t Term, env *Env) int64

type StreamMode

+ func (m StreamMode) String() string

type StreamType

+ func (t StreamType) String() string

type Term

+ Compare func(Term, *Env) int64

type Variable

+ func (v Variable) Compare(t Term, env *Env) int64

Dec 11, 2021

Changes in this version

+ type State struct

+ func (state *State) Abolish(pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) AssertStatic(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Asserta(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Assertz(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) BagOf(template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) BuiltIn(pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Call(goal Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Catch(goal, catcher, recover Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CharConversion(inChar, outChar Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Clause(head, body Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Close(streamOrAlias, options Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentCharConversion(inChar, outChar Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentInput(stream Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentOp(priority, specifier, operator Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentOutput(stream Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentPredicate(pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) CurrentPrologFlag(flag, value Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Dynamic(pi Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) ExpandTerm(term1, term2 Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) FindAll(template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) FlushOutput(streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) GetByte(streamOrAlias, inByte Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) GetChar(streamOrAlias, char Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Negation(goal Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Op(priority, specifier, operator Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Open(SourceSink, mode, stream, options Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Parser(r io.Reader, vars *[]ParsedVariable) *Parser

+ func (state *State) PeekByte(streamOrAlias, inByte Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) PeekChar(streamOrAlias, char Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) PutByte(streamOrAlias, byt Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) PutCode(streamOrAlias, code Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) ReadTerm(streamOrAlias, out, options Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Repeat(k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) Retract(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetInput(streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetOf(template, goal, instances Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetOutput(streamOrAlias Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetPrologFlag(flag, value Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetStreamPosition(streamOrAlias, position Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) SetUserInput(f *os.File)

+ func (state *State) SetUserOutput(f *os.File)

+ func (state *State) StreamProperty(streamOrAlias, property Term, k func(*Env) *Promise, env *Env) *Promise

+ func (state *State) WriteTerm(streamOrAlias, t, options Term, k func(*Env) *Promise, env *Env) *Promise

type VM

+ func (vm *VM) Arrive(pi ProcedureIndicator, args []Term, k func(*Env) *Promise, env *Env) *Promise

Dec 5, 2021

Changes in this version

+ const StreamModeAppend

+ const StreamModeRead

+ const StreamModeWrite

+ var ErrInsufficient = errors.New("insufficient input")

+ var ErrNotANumber = errors.New("not a number")

+ func Contains(t, s Term, env *Env) bool

+ func EachList(list Term, f func(elem Term) error, env *Env) error

+ func EachSeq(seq Term, sep Atom, f func(elem Term) error, env *Env) error

+ func Write(w io.Writer, t Term, opts WriteTermOptions, env *Env) error

+ type Atom string

+ func (a Atom) Apply(args ...Term) Term

+ func (a Atom) String() string

+ func (a Atom) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (a Atom) Unparse(emit func(Token), opts WriteTermOptions, _ *Env)

+ type Compound struct

+ Args []Term

+ Functor Atom

+ func (c *Compound) String() string

+ func (c *Compound) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (c *Compound) Unparse(emit func(Token), opts WriteTermOptions, env *Env)

+ type DoubleQuotes int

+ const DoubleQuotesAtom

+ const DoubleQuotesChars

+ const DoubleQuotesCodes

+ func (d DoubleQuotes) String() string

+ type EOFAction int

+ const EOFActionEOFCode

+ const EOFActionError

+ const EOFActionReset

+ type Env struct

+ func NewEnv() *Env

+ func (e *Env) Bind(k Variable, v Term) *Env

+ func (e *Env) FreeVariables(ts ...Term) Variables

+ func (e *Env) Lookup(k Variable) (Term, bool)

+ func (e *Env) Resolve(t Term) Term

+ func (e *Env) Simplify(t Term) Term

+ type Float float64

+ func (f Float) String() string

+ func (f Float) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (f Float) Unparse(emit func(Token), _ WriteTermOptions, _ *Env)

+ type Integer int64

+ func (i Integer) String() string

+ func (i Integer) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (i Integer) Unparse(emit func(token Token), _ WriteTermOptions, _ *Env)

+ func (i Integer) WriteTerm(w io.Writer, _ WriteTermOptions, _ *Env) error

+ type Lexer struct

+ func NewLexer(input *bufio.Reader, charConversions map[rune]rune) *Lexer

+ func (l *Lexer) Next() (Token, error)

+ type Operator struct

+ Name Atom

+ Priority Integer

+ Specifier OperatorSpecifier

+ type OperatorSpecifier uint8

+ const OperatorSpecifierFX

+ const OperatorSpecifierFY

+ const OperatorSpecifierNone

+ const OperatorSpecifierXF

+ const OperatorSpecifierXFX

+ const OperatorSpecifierXFY

+ const OperatorSpecifierYF

+ const OperatorSpecifierYFX

+ func (s OperatorSpecifier) Term() Term

+ type Operators []Operator

+ type ParsedVariable struct

+ Count int

+ Name Atom

+ Variable Variable

+ type Parser struct

+ func NewParser(input *bufio.Reader, charConversions map[rune]rune, opts ...ParserOption) *Parser

+ func (p *Parser) More() bool

+ func (p *Parser) Number() (Term, error)

+ func (p *Parser) Replace(placeholder Atom, args ...interface{}) error

+ func (p *Parser) Term() (Term, error)

+ type ParserOption func(p *Parser)

+ func WithDoubleQuotes(quotes DoubleQuotes) ParserOption

+ func WithOperators(operators *Operators) ParserOption

+ func WithParsedVars(vars *[]ParsedVariable) ParserOption

type ProcedureIndicator

+ func NewProcedureIndicator(pi Term, env *Env) (ProcedureIndicator, error)

+ type Promise struct

+ func Bool(ok bool) *Promise

+ func Catch(recover func(error) *Promise, k func(context.Context) *Promise) *Promise

+ func Cut(parent *Promise, k func(context.Context) *Promise) *Promise

+ func Delay(k ...func(context.Context) *Promise) *Promise

+ func Error(err error) *Promise

+ func (p *Promise) Force(ctx context.Context) (bool, error)

+ type Stream struct

+ func NewStream(f *os.File, mode StreamMode, opts ...StreamOption) *Stream

+ func Open(name Atom, mode StreamMode, opts ...StreamOption) (*Stream, error)

+ func (s *Stream) Close() error

+ func (s *Stream) String() string

+ func (s *Stream) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (s *Stream) Unparse(emit func(Token), _ WriteTermOptions, _ *Env)

+ type StreamMode int

+ type StreamOption func(*Stream)

+ func WithAlias(vm *VM, alias Atom) StreamOption

+ func WithEOFAction(eofAction EOFAction) StreamOption

+ func WithReposition(b bool) StreamOption

+ func WithStreamType(streamType StreamType) StreamOption

+ type StreamType int

+ const StreamTypeBinary

+ const StreamTypeText

+ type Term interface

+ Unify func(Term, bool, *Env) (*Env, bool)

+ Unparse func(func(Token), WriteTermOptions, *Env)

+ func Cons(car, cdr Term) Term

+ func List(ts ...Term) Term

+ func ListRest(rest Term, ts ...Term) Term

+ func Rulify(t Term, env *Env) Term

+ func Seq(sep Atom, ts ...Term) Term

+ func Set(ts ...Term) Term

+ type Token struct

+ Kind TokenKind

+ Val string

+ func (t Token) String() string

+ type TokenKind byte

+ const TokenBar

+ const TokenBraceL

+ const TokenBraceR

+ const TokenBracketL

+ const TokenBracketR

+ const TokenComma

+ const TokenDoubleQuoted

+ const TokenEOS

+ const TokenFloat

+ const TokenGraphic

+ const TokenIdent

+ const TokenInteger

+ const TokenParenL

+ const TokenParenR

+ const TokenPeriod

+ const TokenQuotedIdent

+ const TokenSign

+ const TokenVariable

+ func (k TokenKind) String() string

+ type UnexpectedRuneError struct

+ func (e UnexpectedRuneError) Error() string

+ type UnexpectedTokenError struct

+ Actual Token

+ ExpectedKind TokenKind

+ ExpectedVals []string

+ History []Token

+ func (e UnexpectedTokenError) Error() string

type VM

+ func (vm *VM) AssertStatic(t Term, k func(*Env) *Promise, env *Env) *Promise

+ func (vm *VM) BuiltIn(pi Term, k func(*Env) *Promise, env *Env) *Promise

+ type Variable string

+ func NewVariable() Variable

+ func (v Variable) Generated() bool

+ func (v Variable) String() string

+ func (v Variable) Unify(t Term, occursCheck bool, env *Env) (*Env, bool)

+ func (v Variable) Unparse(emit func(token Token), opts WriteTermOptions, env *Env)

+ type Variables []Variable

+ func (vs Variables) Except(ws Variables) Variables

+ func (vs Variables) Terms() []Term

+ type WriteTermOptions struct

+ Descriptive bool

+ NumberVars bool

+ Ops Operators

+ Priority int

+ Quoted bool

Nov 21, 2021

Changes in this version

type Exception

+ func DomainError(validDomain term.Atom, culprit term.Interface, format string, ...) *Exception

+ func ExistenceError(objectType term.Atom, culprit term.Interface, format string, ...) *Exception

+ func InstantiationError(culprit term.Interface) *Exception

+ func PermissionError(operation, permissionType term.Atom, culprit term.Interface, format string, ...) *Exception

+ func SystemError(err error) *Exception

+ func TypeError(validType term.Atom, culprit term.Interface, format string, ...) *Exception

type VM

+ func (vm *VM) ExpandTerm(term1, term2 term.Interface, k func(*term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

Oct 9, 2021

Changes in this version

+ func Halt(n term.Interface, k func(*term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Slice(list term.Interface, env *term.Env) ([]term.Interface, error)

+ type ProcedureIndicator struct

+ Arity term.Integer

+ Name term.Atom

+ func (p ProcedureIndicator) Apply(args []term.Interface) (term.Interface, error)

+ func (p ProcedureIndicator) String() string

+ func (p ProcedureIndicator) Term() term.Interface

type VM

+ OnUnknown func(pi ProcedureIndicator, args []term.Interface, env *term.Env)

+ func (vm *VM) FindAll(template, goal, instances term.Interface, k func(*term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Parser(r io.Reader, vars *[]term.ParsedVariable) *term.Parser

+ func (vm *VM) Repeat(k func(*term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

Aug 22, 2021

Changes in this version

+ var DefaultFunctionSet = FunctionSet

+ func Arg(nth, t, arg term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func AtomChars(atom, chars term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func AtomCodes(atom, codes term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func AtomConcat(atom1, atom2, atom3 term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func AtomLength(atom, length term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func CharCode(char, code term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Compare(order, term1, term2 term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func CopyTerm(in, out term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Each(list term.Interface, f func(elem term.Interface) error, env term.Env) error

+ func Failure(_ term.Env) *nondet.Promise

+ func Functor(t, name, arity term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func NumberChars(num, chars term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func NumberCodes(num, codes term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Repeat(k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func SubAtom(atom, before, length, after, subAtom term.Interface, ...) *nondet.Promise

+ func Success(_ term.Env) *nondet.Promise

+ func Throw(ball term.Interface, _ func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func TypeAtom(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func TypeCompound(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func TypeFloat(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func TypeInteger(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func TypeVar(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Unify(t1, t2 term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func UnifyWithOccursCheck(t1, t2 term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func Univ(t, list term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ type Exception struct

+ Term term.Interface

+ func (e *Exception) Error() string

+ type FunctionSet struct

+ Binary map[term.Atom]func(x, y term.Interface, env *term.Env) (term.Interface, error)

+ Unary map[term.Atom]func(x term.Interface, env *term.Env) (term.Interface, error)

+ func (fs FunctionSet) Equal(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (fs FunctionSet) GreaterThan(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (fs FunctionSet) GreaterThanOrEqual(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (fs FunctionSet) Is(result, expression term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (fs FunctionSet) LessThan(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (fs FunctionSet) LessThanOrEqual(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (fs FunctionSet) NotEqual(lhs, rhs term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ type VM struct

+ CharConversions map[rune]rune

+ OnCall func(pi string, args term.Interface, env term.Env)

+ OnExit func(pi string, args term.Interface, env term.Env)

+ OnFail func(pi string, args term.Interface, env term.Env)

+ OnRedo func(pi string, args term.Interface, env term.Env)

+ Operators term.Operators

+ UnknownWarning func(procedure string)

+ func (vm *VM) Abolish(pi term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Asserta(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Assertz(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) BagOf(template, goal, instances term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Call(goal term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Catch(goal, catcher, recover term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) CharConversion(inChar, outChar term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Clause(head, body term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Close(streamOrAlias, options term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Conjunction(p, q term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) CurrentCharConversion(inChar, outChar term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) CurrentInput(stream term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) CurrentOp(priority, specifier, operator term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) CurrentOutput(stream term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) CurrentPredicate(pi term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) CurrentPrologFlag(flag, value term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) DescribeTerm(t term.Interface, env term.Env) string

+ func (vm *VM) Disjunction(p, q term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Dynamic(pi term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) FlushOutput(streamOrAlias term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) GetByte(streamOrAlias, inByte term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) GetChar(streamOrAlias, char term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Halt(n term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) IfThenElse(if_, then_, else_ term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Negation(goal term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) Op(priority, specifier, operator term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Open(SourceSink, mode, stream, options term.Interface, ...) *nondet.Promise

+ func (vm *VM) PeekByte(streamOrAlias, inByte term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) PeekChar(streamOrAlias, char term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) PutByte(streamOrAlias, byt term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) PutCode(streamOrAlias, code term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) ReadTerm(streamOrAlias, out, options term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) Register0(name string, p func(func(term.Env) *nondet.Promise, *term.Env) *nondet.Promise)

+ func (vm *VM) Register1(name string, ...)

+ func (vm *VM) Register2(name string, ...)

+ func (vm *VM) Register3(name string, ...)

+ func (vm *VM) Register4(name string, ...)

+ func (vm *VM) Register5(name string, ...)

+ func (vm *VM) Retract(t term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) SetInput(streamOrAlias term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) SetOf(template, goal, instances term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) SetOutput(streamOrAlias term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) SetPrologFlag(flag, value term.Interface, k func(term.Env) *nondet.Promise, env *term.Env) *nondet.Promise

+ func (vm *VM) SetStreamPosition(streamOrAlias, position term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) SetUserInput(r io.Reader)

+ func (vm *VM) SetUserOutput(w io.Writer)

+ func (vm *VM) StreamProperty(streamOrAlias, property term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise

+ func (vm *VM) WriteTerm(streamOrAlias, t, options term.Interface, k func(term.Env) *nondet.Promise, ...) *nondet.Promise