feature request time/1 and/or statistics/2 predicate

[Jean-Luc-Picard-2021]

Would it be possible to have some time/1 and
statistics/2 predicate? Its not listed here:

https://github.com/ichiban/prolog/wiki

Which is understandable, since the ISO core
standard doesn't mention it. But how

about implementing it nevertheless since
many Prolog systems provide it now?

[ichiban]

What are you going to achieve with time/1 and statistics/2?

Since time/1 prints the result, it doesn't make sense to implement in this library. It might be useful in 1pl, though. Anyways, it'll be trivial to implement your own version as a custom predicate.

As for statistics/2, we might not be able to provide meaningful implementation since the internal structure is wildly different from other implementations.

[Jean-Luc-Picard-2021]

In case I would need to write my own time/1 I would
need statistics/2 anyway. Or is there some cpu_time evaluable
function. Didn't check yet.

time/1 is usually bootstrapped from statistics/2, but bootstrapping
time/1 is non triviail. time/1 has to cease time measurement while
the query prompt is shown, and time/1 can also measure

different backtracking results, like here in SWI-Prolog:

?- time((sleep(0.1);sleep(0.1))).
% -2 inferences, 0.000 CPU in 0.111 seconds (0% CPU, Infinite Lips)
true ;
% 7 inferences, 0.000 CPU in 0.104 seconds (0% CPU, Infinite Lips)
true.

A novice programmer doesn't know how to implement it. A
more advanced programmer can implement it, but you need
some state record, does Ichinban Prolog have a change_arg/3

predicate? It goes by the name nb_setarg/3.

[ichiban]

You can define your own time/1 (and also sleep/1) like this:

package main

import (
	"fmt"
	"time"

	"github.com/ichiban/prolog"
	"github.com/ichiban/prolog/engine"
)

func main() {
	p := prolog.New(nil, nil)

	p.Register1(engine.NewAtom("time"), func(vm *engine.VM, g engine.Term, k engine.Cont, env *engine.Env) *engine.Promise {
		t := time.Now()
		return engine.Call(vm, g, func(env *engine.Env) *engine.Promise {
			fmt.Printf("time: %s\n", time.Now().Sub(t))
			t = time.Now()
			return k(env)
		}, env)
	})

	p.Register1(engine.NewAtom("sleep"), func(_ *engine.VM, s engine.Term, k engine.Cont, env *engine.Env) *engine.Promise {
		var d time.Duration
		switch s := env.Resolve(s).(type) {
		case engine.Variable:
			return engine.Error(engine.InstantiationError(env))
		case engine.Integer:
			d = time.Duration(s) * time.Second
		case engine.Float:
			d = time.Duration(s * engine.Float(time.Second))
		default:
			return engine.Error(engine.TypeError(engine.NewAtom("number"), s, env))
		}
		time.Sleep(d)
		return k(env)
	})

	sols, err := p.Query(`time((sleep(0.1);sleep(0.1))).`)
	if err != nil {
		panic(err)
	}

	for sols.Next() {
	}

	if err := sols.Close(); err != nil {
		panic(err)
	}
}

time: 100ms
time: 100ms

Program exited.

https://go.dev/play/p/joiuZW3tzpw