chapter A self-hosting (wip)

Author: metaleap

hello.lisp

@@ -1,4 +1,5 @@
 ; run with: `rlwrap go run *.go hello.lisp` or `rlwrap go run *.go hello.lisp World`
+; — or load this in a REPL session started with `rlwrap go run *.go` by calling `(loadFile "hello.lisp")`
 
 (def greet
     (fn (name)
@@ -7,7 +8,7 @@
         (if (= "" name)
             (set repeat :false)
             (println "Hello, " name "!"))
-        (if repeat (greet :nil) :nil)))
+        (if repeat (greet :nil))))
 
 (if (isEmpty osArgs)
     (greet :nil)

main.go

@@ -91,7 +91,10 @@ const srcMiniStdlibNonMacros = `
 			()
 			(cons (func (first list)) (map func (rest list))))))
 
-
+(def condBrokenUseCaseOf
+	(macro (& xs)
+		(if (> (count xs) 0)
+			(list 'if (first xs) (if (> (count xs) 1) (nth xs 1) (throw "odd number of forms to cond")) (cons 'cond (rest (rest xs)))))))
 `
 
 const srcMiniStdlibMacros = `

self-hosted/README.md

@@ -0,0 +1 @@
+All adapted from https://github.com/kanaka/mal/blob/master/impls/mal/

self-hosted/step0_repl.lisp

@@ -0,0 +1,25 @@
+;; read
+(def READ (fn [strng]
+  strng))
+
+;; eval
+(def EVAL (fn [ast]
+  ast))
+
+;; print
+(def PRINT (fn [exp] exp))
+
+;; repl
+(def rep (fn [strng]
+  (PRINT (EVAL (READ strng)))))
+
+;; repl loop
+(def repl-loop (fn [line]
+  (if line
+    (do
+      (if (not (= "" line))
+        (println (rep line)))
+      (repl-loop (readLine "mal-user> "))))))
+
+;; main
+(repl-loop "")

self-hosted/step1_read_print.lisp

@@ -0,0 +1,28 @@
+;; read
+(def READ readExpr)
+
+
+;; eval
+(def EVAL (fn [ast]
+  ast))
+
+;; print
+(def PRINT str)
+
+;; repl
+(def rep (fn [strng]
+  (PRINT (EVAL (READ strng)))))
+
+;; repl loop
+(def repl-loop (fn [line]
+  (if line
+    (do
+      (if (not (= "" line))
+        (try
+          (println (rep line))
+          (catch exc
+            (println "Uncaught exception:" exc))))
+      (repl-loop (readLine "mal-user> "))))))
+
+;; main
+(repl-loop "")

special_forms.go

@@ -30,6 +30,11 @@ func init() { // in here, instead of above, to avoid "initialization cycle" erro
 	}
 }
 
+// like the funcs in `std.go`, the special-forms return an `Expr, error`. but:
+// in addition, they also return an `*Env`. if that is `nil`, the returned Expr
+// is a complete result, just like with the std funcs. but if not, the TCO loop
+// in `evalAndApply` goes through another iteration with the returned Expr.
+
 func stdDef(env *Env, args []Expr) (*Env, Expr, error) {
 	return defOrSet(true, env, args)
 }
@@ -123,15 +128,18 @@ func stdLet(env *Env, args []Expr) (*Env, Expr, error) {
 }
 
 func stdIf(env *Env, args []Expr) (*Env, Expr, error) {
-	if err := checkArgsCount(3, 3, args); err != nil {
+	if err := checkArgsCount(2, 3, args); err != nil {
 		return nil, nil, err
 	}
+	if len(args) < 3 {
+		args = append(args, exprNil)
+	}
 	expr, err := evalAndApply(env, args[0])
 	if err != nil {
 		return nil, nil, err
 	}
 	idx := 1
-	if isEq(expr, exprFalse) || isEq(expr, exprNil) {
+	if isNilOrFalse(expr) {
 		idx = 2
 	}
 	return env, args[idx], nil

std.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -667,21 +666,27 @@ func stdReadLine(args []Expr) (Expr, error) {
 func stdQuit(args []Expr) (Expr, error) {
 	var exit_code ExprNum
 	if len(args) > 0 {
-		exit_code, _ = args[0].(ExprNum)
+		var is_num bool
+		if exit_code, is_num = args[0].(ExprNum); (!is_num) || (exit_code > 255) {
+			exit_code = 255
+		}
 	}
 	os.Exit(int(exit_code))
 	return exprNil, nil
 }
 
 func stdTimeMs(args []Expr) (Expr, error) {
+	if err := checkArgsCount(0, 0, args); err != nil {
+		return nil, err
+	}
 	return ExprNum(time.Now().UnixMilli()), nil
 }
 
 func stdBool(args []Expr) (Expr, error) {
 	if err := checkArgsCount(1, 1, args); err != nil {
 		return nil, err
 	}
-	return exprBool((!isEq(exprFalse, args[0])) && !isEq(exprNil, args[0])), nil
+	return exprBool(!isNilOrFalse(args[0])), nil
 }
 
 func stdSeq(args []Expr) (Expr, error) {
@@ -717,5 +722,22 @@ func stdSeq(args []Expr) (Expr, error) {
 }
 
 func stdConj(args []Expr) (Expr, error) {
-	return nil, errors.New("TODO")
+	if err := checkArgsCount(2, -1, args); err != nil {
+		return nil, err
+	}
+	_, is_vec := args[0].(ExprVec)
+	seq, err := checkIsSeq(args[0])
+	if err != nil {
+		return nil, err
+	}
+	if is_vec {
+		seq = append(seq, args[1:]...)
+		return (ExprVec)(seq), nil
+	} else {
+		new_list := make(ExprList, 0, (len(args)-1)+len(seq))
+		for i := len(args) - 1; i > 0; i-- {
+			new_list = append(new_list, args[i])
+		}
+		return (ExprList)(append(new_list, seq...)), nil
+	}
 }

util.go

@@ -4,6 +4,10 @@ import (
 	"io"
 )
 
+func isNilOrFalse(expr Expr) bool {
+	return isEq(exprNil, expr) || isEq(exprFalse, expr)
+}
+
 func readUntil(r io.Reader, until byte, initialBufCapacity int) (string, error) {
 	buf := make([]byte, 0, initialBufCapacity)
 	var b [1]byte