Added (ms) to record the time in ms.

This is useful for benchmarking, so was added to the factorial
test in our test.lisp.

README.md

@@ -176,7 +176,7 @@ We have a reasonable number of functions implemented, either in our golang core
 
 Building upon those primitives we have a larger standard-library of functions written in Lisp such as:
 
-* `abs`, `apply`, `append`, `cond`, `count`, `filter`, `lower`, `map`, `min`, `max`, `nat`, `neg`, `now`, `nth`, `reduce`, `repeat`, `reverse`, `seq`, `strlen`, `upper`, `when`, `while`, etc.
+* `abs`, `apply`, `append`, `cond`, `count`, `filter`, `lower`, `map`, `min`, `max`, `ms`, `nat`, `neg`, `now`, `nth`, `reduce`, `repeat`, `reverse`, `seq`, `strlen`, `upper`, `when`, `while`, etc.
 
 Although the lists above should be up to date you can check the definitions to see what is currently available:
 

builtins/builtins.go

@@ -86,6 +86,7 @@ func PopulateEnvironment(env *env.Environment) {
 	env.Set("error", &primitive.Procedure{F: errorFn})
 	env.Set("getenv", &primitive.Procedure{F: getenvFn})
 	env.Set("now", &primitive.Procedure{F: nowFn})
+	env.Set("ms", &primitive.Procedure{F: msFn})
 	env.Set("print", &primitive.Procedure{F: printFn})
 	env.Set("sort", &primitive.Procedure{F: sortFn})
 	env.Set("sprintf", &primitive.Procedure{F: sprintfFn})
@@ -693,10 +694,14 @@ func getenvFn(args []primitive.Primitive) primitive.Primitive {
 
 // nowFn is the implementation of `(now)`
 func nowFn(args []primitive.Primitive) primitive.Primitive {
-
 	return primitive.Number(time.Now().Unix())
 }
 
+// msFn is the implementation of `(ms)`
+func msFn(args []primitive.Primitive) primitive.Primitive {
+	return primitive.Number(time.Now().UnixNano() / int64(time.Millisecond))
+}
+
 // matchFn is the implementation of (match ..)
 func matchFn(args []primitive.Primitive) primitive.Primitive {
 

builtins/builtins_test.go

@@ -1349,6 +1349,26 @@ func TestNow(t *testing.T) {
 
 }
 
+func TestMs(t *testing.T) {
+
+	// No arguments
+	out := msFn([]primitive.Primitive{})
+
+	// Will lead to a number
+	e, ok := out.(primitive.Number)
+	if !ok {
+		t.Fatalf("expected number, got %v", out)
+	}
+
+	// Get the current time
+	tm := int(time.Now().UnixNano() / int64(time.Millisecond))
+
+	if math.Abs(float64(tm-int(e))) > 10 {
+		t.Fatalf("weird result; (ms) != ms - outside our bound of ten seconds inaccuracy")
+	}
+
+}
+
 func TestGet(t *testing.T) {
 
 	// no arguments

test.lisp

@@ -43,8 +43,9 @@
 ;; `now` function which times how long it took.
 (apply (list 1 10 100 1000 10000 100000)
        (lambda (x)
-         (let ((start (now)))
-           (print "%s! => %s [%s seconds]" x (fact x) (- (now) start)))))
+         (let ( (start (now))
+                (m     (ms)) )
+           (print "%s! => %s [%s seconds / %s ms]" x (fact x) (- (now) start) (- (ms) m) ))))
 
 
 ; Split a string into a list, reverse it, and join it