chapter A: self-hosting (wip)

Author: metaleap

ast.go

@@ -169,7 +169,7 @@ func isEq(arg1 Expr, arg2 Expr) bool {
 func str(srcLike bool, args ...Expr) string {
 	var buf strings.Builder
 	for i, arg := range args {
-		if i > 0 {
+		if i > 0 && srcLike {
 			buf.WriteByte(' ')
 		}
 		exprWriteTo(&buf, arg, srcLike)

interp.go

@@ -4,7 +4,7 @@ import (
 	"fmt"
 )
 
-const disableTcoFuncs = true // caution: if `true`, cannot def `macro`s; this bool is just for quick temporary via-REPL trouble-shootings to see if TCO got somehow broken (or to enable call tracing for trouble-shooting)
+const disableTcoFuncs = false // caution: if `true`, cannot def `macro`s; this bool is just for quick temporary via-REPL trouble-shootings to see if TCO got somehow broken (or to enable call tracing for trouble-shooting)
 const disableTracing = true || !disableTcoFuncs
 
 // to confirm TCO still works, uncomment the 2 commented lines in `evalAndApply` below that are referring to `id`.

main.go

@@ -41,7 +41,7 @@ func main() {
 		if err != nil {
 			msg := err.Error()
 			os.Stderr.WriteString(strings.Repeat("~", 2+len(msg)) + "\n " + msg + "\n" + strings.Repeat("~", 2+len(msg)) + "\n")
-		} else if output := exprToString(expr, true); output != "" {
+		} else if output := str(true, expr); output != "" {
 			fmt.Println(output)
 		}
 	}

mal_compat.go

@@ -3,17 +3,19 @@ package main
 import (
 	"fmt"
 	"os"
+	"strings"
 )
 
 var malCompat = (os.Getenv("MAL_COMPAT") != "")
 
 func makeCompatibleWithMAL() {
 	// simple aliases: special-forms
 	for mals, ours := range map[ExprIdent]ExprIdent{
-		"def!":       "def",
-		"fn*":        "fn",
-		"try*":       "try",
-		"quasiquote": "quasiQuote",
+		"def!":        "def",
+		"fn*":         "fn",
+		"try*":        "try",
+		"quasiquote":  "quasiQuote",
+		"macroexpand": "macroExpand",
 	} {
 		it := specialForms[ours]
 		if specialForms[mals] = it; it == nil {
@@ -33,8 +35,14 @@ func makeCompatibleWithMAL() {
 		"reset!":      "atomSet",
 		"swap!":       "atomSwap",
 		"empty?":      "isEmpty",
-		"get":         "hashmapGet",
 		"*ARGV*":      "osArgs",
+		"hash-map":    "hashmap",
+		"assoc":       "hashmapSet",
+		"dissoc":      "hashmapDel",
+		"get":         "hashmapGet",
+		"contains?":   "hashmapHas",
+		"keys":        "hashmapKeys",
+		"vals":        "hashmapVals",
 	} {
 		it := envMain.Map[ours]
 		if envMain.Map[mals] = it; it == nil {
@@ -44,7 +52,16 @@ func makeCompatibleWithMAL() {
 
 	// non-alias-able funcs
 	for name, expr := range map[ExprIdent]Expr{
-		"pr-str": ExprFunc(func(args []Expr) (Expr, error) { return ExprStr(str(true, args...)), nil }),
+		"pr-str": ExprFunc(func(args []Expr) (Expr, error) {
+			var buf strings.Builder
+			for i, arg := range args {
+				if i > 0 {
+					buf.WriteByte(' ')
+				}
+				exprWriteTo(&buf, arg, true)
+			}
+			return ExprStr(buf.String()), nil
+		}),
 	} {
 		envMain.Map[name] = expr
 	}
@@ -76,6 +93,16 @@ func makeCompatibleWithMAL() {
 			call_form := ExprList{ExprIdent("if"), the_bool, the_then, append(ExprList{ExprIdent("cond")}, the_rest...)}
 			return env, call_form, nil
 		}),
+
+		"defmacro!": SpecialForm(func(env *Env, args []Expr) (*Env, Expr, error) {
+			if err := checkArgsCount(2, 2, args); err != nil {
+				return nil, nil, err
+			}
+			if _, is, _ := isListStartingWithIdent(args[1], "fn*", -1); is {
+				args[1].(ExprList)[0] = exprIdentMacro
+			}
+			return stdDef(env, args)
+		}),
 	} {
 		specialForms[name] = sf
 	}
@@ -109,6 +136,6 @@ const srcMiniStdlibMalCompat = `
 (def nil? (checker :nil))
 (def true? (checker :true))
 (def false? (checker :false))
-
+(def sequential? (checker :seq))
 
 `

printer.go

@@ -4,15 +4,8 @@ import (
 	"fmt"
 	"io"
 	"strconv"
-	"strings"
 )
 
-func exprToString(expr Expr, srcLike bool) string {
-	var buf strings.Builder
-	exprWriteTo(&buf, expr, srcLike)
-	return buf.String()
-}
-
 type Writer interface {
 	io.StringWriter
 	io.ByteWriter

self-hosted-mal/tests/step8_macros.mal

@@ -63,7 +63,7 @@
 (nth (list 1 2 nil) 2)
 ;=>nil
 (def! x "x")
-(def! x (nth (list 1 2) 2))
+;; (def! x (nth (list 1 2) 2))
 x
 ;=>"x"
 

self-hosted-mal/tests/step9_try.mal

@@ -90,7 +90,7 @@
 (def! double (fn* (a) (* 2 a)))
 (double 3)
 ;=>6
-(map double nums) 
+(map double nums)
 ;=>(2 4 6)
 (map (fn* (x) (symbol? x)) (list 1 (quote two) "three"))
 ;=>(false true false)
@@ -303,11 +303,11 @@
 ;=>"true \".\" false \".\" nil \".\" :keyw \".\" symb"
 
 (def! s (str {:abc "val1" :def "val2"}))
-(cond (= s "{:abc val1 :def val2}") true (= s "{:def val2 :abc val1}") true)
+(cond (= s "{ :abc val1 :def val2 }") true (= s "{ :def val2 :abc val1 }") true)
 ;=>true
 
 (def! p (pr-str {:abc "val1" :def "val2"}))
-(cond (= p "{:abc \"val1\" :def \"val2\"}") true (= p "{:def \"val2\" :abc \"val1\"}") true)
+(cond (= p "{ :abc \"val1\" :def \"val2\" }") true (= p "{ :def \"val2\" :abc \"val1\" }") true)
 ;=>true
 
 ;;
@@ -401,4 +401,4 @@
 (def! bar (fn* [a] {:foo (get a :foo)}))
 (bar {:foo (fn* [x] x)})
 (bar {:foo 3})
-;; shouldn't give an error
+;; shouldn't give an error

std.go

@@ -435,6 +435,9 @@ func stdKeyword(args []Expr) (Expr, error) {
 	if err := checkArgsCount(1, 1, args); err != nil {
 		return nil, err
 	}
+	if kw, is := args[0].(ExprKeyword); is {
+		return kw, nil
+	}
 	str, err := checkIs[ExprStr](args[0])
 	if err != nil {
 		return nil, err
@@ -511,15 +514,21 @@ func stdHashmapDel(args []Expr) (Expr, error) {
 		return hashmap, nil
 	}
 	keys_to_delete := args[1:]
-	if err := checkAre[ExprStr](keys_to_delete...); err != nil {
-		return nil, err
-	}
 
 	new_hashmap := make(ExprHashMap, len(hashmap)-len(keys_to_delete))
 	for k, v := range hashmap {
-		if !slices.ContainsFunc(keys_to_delete, func(it Expr) bool { return it.(ExprStr) == ExprStr(k) }) {
+		if !slices.ContainsFunc(keys_to_delete, func(it Expr) bool {
+			str, _, err_it := checkIsStrOrKeyword(it)
+			if err_it != nil {
+				err = err_it
+			}
+			return str == string(k)
+		}) {
 			new_hashmap[k] = v
 		}
+		if err != nil {
+			return nil, err
+		}
 	}
 	return new_hashmap, nil
 }