update to latest ichiban/prolog

go.mod

@@ -2,4 +2,4 @@ module github.com/guregu/pengine
 
 go 1.18
 
-require github.com/ichiban/prolog v0.10.5
+require github.com/ichiban/prolog v0.11.1

go.sum

@@ -5,6 +5,8 @@ github.com/ichiban/prolog v0.10.4 h1:GL/+f0Abd7llsVnNaFkuIdQPJ+oAlHA2Z82y/5tQfCA
 github.com/ichiban/prolog v0.10.4/go.mod h1:qB0m6pWsd/XghbWmS5D6GExVhEvNqsa+iBPFMpTxS+U=
 github.com/ichiban/prolog v0.10.5 h1:6UpnWeSq1u4NNoxYD61z9qhTw6LR1M3OlxB51ONbnEw=
 github.com/ichiban/prolog v0.10.5/go.mod h1:qB0m6pWsd/XghbWmS5D6GExVhEvNqsa+iBPFMpTxS+U=
+github.com/ichiban/prolog v0.11.1 h1:8lC/qGzUB/M8LM8F+KxMpIC0fUBJQBaKgOFcxNsqvgw=
+github.com/ichiban/prolog v0.11.1/go.mod h1:qB0m6pWsd/XghbWmS5D6GExVhEvNqsa+iBPFMpTxS+U=
 github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
 github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
 github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=

pengines_test.go

@@ -38,7 +38,7 @@ func TestPengines(t *testing.T) {
 		engine.Integer(1),
 		engine.Float(2.1),
 		engine.Atom("あ"),
-		&engine.Compound{Functor: "b", Args: []engine.Term{engine.Atom("c")}},
+		engine.Atom("b").Apply(engine.Atom("c")),
 		engine.List(engine.Atom("d")),
 	}
 

predicate.go

@@ -46,7 +46,7 @@ func rpc(p *prolog.Interpreter) func(url, query, options engine.Term, k func(*en
 
 		query = env.Simplify(query)
 		var q strings.Builder
-		if err := query.WriteTerm(&q, &engine.WriteOptions{
+		if err := engine.WriteTerm(&q, query, &engine.WriteOptions{
 			Quoted:    true,
 			IgnoreOps: true,
 		}, env); err != nil {
@@ -57,36 +57,36 @@ func rpc(p *prolog.Interpreter) func(url, query, options engine.Term, k func(*en
 		for iter.Next() {
 			cur := env.Resolve(iter.Current())
 			switch x := cur.(type) {
-			case *engine.Compound:
-				switch x.Functor {
+			case engine.Compound:
+				switch x.Functor() {
 				case "application":
-					str := term2str(x.Args[0], env)
+					str := term2str(x.Arg(0), env)
 					if str == "" {
-						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Args[0], env))
+						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Arg(0), env))
 					}
 					client.Application = str
 				case "chunk":
-					n, ok := env.Resolve(x.Args[0]).(engine.Integer)
+					n, ok := env.Resolve(x.Arg(0)).(engine.Integer)
 					if !ok {
-						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Args[0], env))
+						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Arg(0), env))
 					}
 					client.Chunk = int(n)
 				case "src_text":
-					str := term2str(x.Args[0], env)
+					str := term2str(x.Arg(0), env)
 					if str == "" {
-						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Args[0], env))
+						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Arg(0), env))
 					}
 					client.SourceText = str
 				case "src_url":
-					str := term2str(x.Args[0], env)
+					str := term2str(x.Arg(0), env)
 					if str == "" {
-						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Args[0], env))
+						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Arg(0), env))
 					}
 					client.SourceURL = str
 				case "debug":
-					str := term2str(x.Args[0], env)
+					str := term2str(x.Arg(0), env)
 					if str == "" {
-						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Args[0], env))
+						return engine.Error(engine.TypeError(engine.ValidTypeAtom, x.Arg(0), env))
 					}
 					client.Debug = str == "true"
 				}
@@ -127,7 +127,7 @@ func doRPC(as *prologAnswers, query engine.Term, k func(*engine.Env) *engine.Pro
 
 func stringify(t engine.Term) string {
 	var q strings.Builder
-	_ = t.WriteTerm(&q, &engine.WriteOptions{
+	_ = engine.WriteTerm(&q, t, &engine.WriteOptions{
 		Quoted:    true,
 		IgnoreOps: false,
 	}, nil)

prolog.go

@@ -99,14 +99,14 @@ func (p *prologAnswers) handle(ctx context.Context, a string) error {
 		return fmt.Errorf("pengines: failed to parse response: %w", err)
 	}
 
-	event, ok := t.(*engine.Compound)
+	event, ok := t.(engine.Compound)
 	if !ok {
 		return fmt.Errorf("unexpected event type: %T (value: %v)", t, t)
 	}
 	return p.handleEvent(event)
 }
 
-func (p *prologAnswers) handleEvent(t *engine.Compound) error {
+func (p *prologAnswers) handleEvent(t engine.Compound) error {
 	/*
 		% Original script looked like:
 
@@ -138,25 +138,25 @@ func (p *prologAnswers) handleEvent(t *engine.Compound) error {
 			'$pengine_output'(ID, Term).
 
 	*/
-	switch t.Functor {
+	switch t.Functor() {
 	case "success": // success/5
 		// id, results, projection, time, more
-		return p.onSuccess(t.Args[0], t.Args[1], t.Args[2], t.Args[3], t.Args[4])
+		return p.onSuccess(t.Arg(0), t.Arg(1), t.Arg(2), t.Arg(3), t.Arg(4))
 	case "failure": // failure/2
 		// id, time
-		return p.onFailure(t.Args[0], t.Args[1])
+		return p.onFailure(t.Arg(0), t.Arg(1))
 	case "error": // error/2
 		// id, ball
-		return p.onError(t.Args[0], t.Args[1])
+		return p.onError(t.Arg(0), t.Arg(1))
 	case "create": // create/2
 		// id, list
-		return p.onCreate(t.Args[0], t.Args[1])
+		return p.onCreate(t.Arg(0), t.Arg(1))
 	case "destroy": // destroy/2
 		// id, event
-		return p.onDestroy(t.Args[0], t.Args[1])
+		return p.onDestroy(t.Arg(0), t.Arg(1))
 	case "output": // output/2
 		// TODO: unimplemented
-		return p.onOutput(t.Args[0], t.Args[1])
+		return p.onOutput(t.Arg(0), t.Arg(1))
 	case "prompt": // prompt/2
 		// TODO
 	}
@@ -209,7 +209,7 @@ func (p *prologAnswers) onOutput(id, term engine.Term) error {
 
 func (p *prologAnswers) onDestroy(id, t engine.Term) error {
 	p.eng.die()
-	goal, ok := t.(*engine.Compound)
+	goal, ok := t.(engine.Compound)
 	if ok {
 		return p.handleEvent(goal)
 	}
@@ -227,15 +227,15 @@ func (p *prologAnswers) onCreate(id, data engine.Term) error {
 	for iter.Next() {
 		cur := iter.Current()
 		switch t := cur.(type) {
-		case *engine.Compound:
-			switch t.Functor {
+		case engine.Compound:
+			switch t.Functor() {
 			case "slave_limit":
-				n, ok := t.Args[0].(engine.Integer)
+				n, ok := t.Arg(0).(engine.Integer)
 				if ok {
 					p.eng.openLimit = int(n)
 				}
 			case "answer":
-				goal, ok := t.Args[0].(*engine.Compound)
+				goal, ok := t.Arg(0).(engine.Compound)
 				if ok {
 					defer p.handleEvent(goal)
 				}
@@ -247,22 +247,5 @@ func (p *prologAnswers) onCreate(id, data engine.Term) error {
 
 // resolve is a version of Simplify that attempts to loosely occurs-check itself to prevent infinite loops
 func resolve(t engine.Term, env *engine.Env, seen map[engine.Term]struct{}) engine.Term {
-	if seen == nil {
-		seen = make(map[engine.Term]struct{})
-	}
-
-	if _, ok := seen[t]; ok {
-		return t
-	}
-	seen[t] = struct{}{}
-
-	switch t := env.Resolve(t).(type) {
-	case *engine.Compound:
-		for i, arg := range t.Args {
-			t.Args[i] = resolve(arg, env, seen)
-		}
-		return t
-	default:
-		return t
-	}
+	return env.Resolve(t)
 }

prolog_test.go

@@ -29,12 +29,12 @@ func TestProlog(t *testing.T) {
 
 	for as.Next(ctx) {
 		t.Logf("answer: %+v", as.Current())
-		cmp, ok := as.Current().(*engine.Compound)
+		cmp, ok := as.Current().(engine.Compound)
 		if !ok {
 			t.Fatal("not a compound", as.Current())
 		}
-		if cmp.Functor != "子" {
-			t.Error("unexpected functor. want: 子 got:", cmp.Functor)
+		if cmp.Functor() != "子" {
+			t.Error("unexpected functor. want: 子 got:", cmp.Functor())
 		}
 	}
 	if err := as.Err(); err != nil {

term.go

@@ -111,14 +111,11 @@ func (t Term) Prolog() engine.Term {
 		}
 		return engine.Integer(n)
 	case t.Compound != nil:
-		c := &engine.Compound{
-			Functor: engine.Atom(t.Compound.Functor),
-			Args:    make([]engine.Term, 0, len(t.Compound.Args)),
-		}
+		args := make([]engine.Term, 0, len(t.Compound.Args))
 		for _, arg := range t.Compound.Args {
-			c.Args = append(c.Args, arg.Prolog())
+			args = append(args, arg.Prolog())
 		}
-		return c
+		return engine.Atom(t.Compound.Functor).Apply(args...)
 	case t.Variable != nil:
 		// TODO(guregu): what should this be? engine.NewVariable? Is this even useful?
 		return engine.Variable(*t.Variable)