Reorganized basically everything, making way for the compiler

2025-11-15 13:06:16 +03:00
parent 27115ab4f2
commit 3f0a860a03
15 changed files with 84 additions and 25 deletions
--- a/interpreter/ast.ml
+++ b/interpreter/ast.ml
@@ -0,0 +1,142 @@
+
+(* This is different from the lisp_ast data returned by the parser!
+   We will first need to translate that into this in order to use it.
+   This representation includes things that can only occur during runtime,
+   like the various kinds of functions and macros.
+
+   Additionally, since this is an interpreter, macros tend to be a little
+   awkward in that they behave exactly like the macro gets expanded just
+   before the result gets executed. This is different from the compiled
+   behaviour where the macro is evaluated at compile time.
+
+   Though of course, with the dynamic nature of lisp, and its capability
+   to compile more code at runtime, there will naturally be complications.
+ *)
+type lisp_val = 
+  | LInt of int 
+  | LDouble of float 
+  | LCons of lisp_val * lisp_val
+  | LNil
+  | LSymbol of string
+  | LString of string
+  
+  (* a builtin function is expressed as a name and the ocaml function
+  that performs the operation. The function should take a list of arguments.
+  generally, builtin functions should handle their arguments directly,
+  and eval forms in the environment as necessary. *)
+  | LBuiltinFunction of string * (environment -> lisp_val -> lisp_val)
+  | LBuiltinSpecial of string * (environment -> lisp_val -> lisp_val)
+  (* a function is a name, captured environment, a parameter list, and function body. *)
+  | LFunction of string * environment * lisp_val * lisp_val
+  | LLambda of environment * lisp_val * lisp_val
+  (* a macro is exactly the same as a function, with the distinction
+     that it receives all of its arguments completely unevaluated
+   *)
+  | LMacro of string * environment * lisp_val * lisp_val
+  | LUnnamedMacro of environment * lisp_val * lisp_val
+  | LQuoted of lisp_val
+(* the environment type needs to be defined here, as it is mutually
+ recursive with lisp_val *)
+and environment = (string, lisp_val) Hashtbl.t list
+
+(* It is clear that we need some primitives for working with the lisp
+   data structures.
+
+   For example, the LCons and LNil values, together, form a linked list.
+   This is the intended form of all source code in lisp, yet because
+   we are using our own implementation of a linked list instead of
+   ocaml's List, we can not use its many functions.
+
+   It may be tempting to switch to a different implementation.
+   Remember however, that classic lisp semantics allow for the
+   CDR component of a cons cell (the part that would point to the
+   next member) to be of a type other than the list itself.
+ *)
+
+let reverse vs =
+  let rec aux prev = function
+    | LNil -> prev
+    | LCons (v, next) -> aux (LCons (v, prev)) next
+    | _ -> invalid_arg "cannot reverse non-list!"
+  in aux LNil vs
+
+let map f =
+  let rec aux accum = function
+    | LNil -> reverse accum
+    | LCons (v, next) -> aux (LCons (f v, accum)) next
+    | _ -> invalid_arg "cannot map over non-list!"
+  in aux LNil
+
+let reduce init f =
+  let rec aux accum = function
+    | LNil -> accum
+    | LCons (v, next) -> aux (f accum v) next
+    | _ -> invalid_arg "cannot reduce over non-list!"
+  in aux init
+
+let rec dbg_print_list =
+  let pf = Printf.sprintf in
+  function
+  | LCons (v, LNil) -> pf "%s" (dbg_print_one v)
+  | LCons (v, rest) -> (pf "%s " (dbg_print_one v)) ^ (dbg_print_list rest)
+  | v -> pf ". %s" (dbg_print_one v)
+
+and dbg_print_one v =
+  let pf = Printf.sprintf in
+  match v with
+  | LInt x ->  pf "<int: %d>" x
+  | LSymbol s -> pf "<symbol: '%s'>" s
+  | LString s -> pf "<string: '%s'>" s
+  | LNil -> pf "<nil>"
+  | LCons _ -> pf "<list: (%s)>" (dbg_print_list v) 
+  | LDouble d -> pf "<double: %f>" d
+  | LBuiltinSpecial (name, _)
+  | LBuiltinFunction (name, _) -> pf "<builtin: %s>" name
+  | LLambda (_, args, _) -> pf "<unnamed function, lambda-list: %s>"
+    (dbg_print_one args)
+  | LFunction (name, _, args, _) -> pf "<function: '%s' lambda-list: %s>" 
+    name (dbg_print_one args)
+  | LUnnamedMacro (_, args, _) -> pf "<unnamed macro, lambda-list: %s>"
+    (dbg_print_one args)
+  | LMacro (name, _, args, _) -> pf "<macro '%s' lambda-list: %s>"
+    name (dbg_print_one args)
+  | LQuoted v -> pf "<quote: %s>" (dbg_print_one v)
+  (*| _ -> "<Something else>"*)
+
+let rec pretty_print_one v =
+  let pf = Printf.sprintf in
+  match v with
+  | LInt x -> pf "%d" x
+  | LSymbol s -> pf "%s" s
+  | LString s -> pf "\"%s\"" s
+  | LNil -> pf "()"
+  | LCons (a, b) -> pf "(%s)" (dbg_print_list (LCons (a,b)))
+  | LDouble d -> pf "%f" d
+  | LQuoted v -> pf "'%s" (pretty_print_one v)
+  | LBuiltinSpecial _
+  | LBuiltinFunction _ 
+  | LLambda _
+  | LFunction _
+  | LUnnamedMacro _
+  | LMacro _  -> dbg_print_one v
+
+let pretty_print_all vs =
+  let pr v = Printf.printf "%s\n" (pretty_print_one v) in
+  List.iter pr vs
+
+let dbg_print_all vs =
+  let pr v = Printf.printf "%s\n" (dbg_print_one v) in
+  List.iter pr vs
+
+
+let rec convert_one = function
+  | Parser.Ast.LInt x -> LInt x
+  | Parser.Ast.LDouble x -> LDouble x
+  | Parser.Ast.LNil -> LNil
+  | Parser.Ast.LString s -> LString s
+  | Parser.Ast.LSymbol s -> LSymbol s
+  | Parser.Ast.LCons (a, b) -> LCons (convert_one a, convert_one b)
+
+
+let read_from_str s =
+  List.map convert_one (Parser.parse_str s)