Remove interfaces and refactor AST

Author: engboris

examples/syntax.sg

@@ -18,6 +18,10 @@
 (:= y (-f a))
 <show exec (union @#x #y)>
 
+'complex identifiers
+(:= (f a b) [(function a b)])
+(show #(f a b))
+
 'show (literal) contellations
 (show [ [a] [b] [c] ])
 
@@ -52,47 +56,33 @@
 <show eval exec (union #g @[-test1])>
 <show eval exec (union #g @[-test2])>
 
-'''
-'reactive effects
-(run (const
-  (star (+&print X))
-  (star (-&print "hello world\n"))))
-
-'access to field of a galaxy
-(show (get g test1))
-(show (get g test2))
-
 'extend rays with a head function symbol
-(show-exec (const (star (+f X)) (star (f X)))[=>+a])
-(show-exec (const (star (+f X)) (star (f X)))[=>a])
+'<show exec [[(+f X)] [(f X)]][=>+a]>
+'<show exec [[(+f X)] [(f X)]][=>a]>
 
 'remove head function symbol from a ray
-(show-exec (const (star (+f X)) (star (f X)))[+f=>])
+'<show-exec [[(+f X)] [(f X)]][+f=>]>
 
 'substitutions
-(show-exec
-  (const (star (+f X)))[X=>(+a X)])
-(show-exec (const (star (+f X)))[+f=>+g])
-(show-exec (union #1 #2)
-  [#1=>(const (star (+f X) X))]
-  [#2=>(const (star (-f a)))])
+'<show exec (+f X)[X=>(+a X)]>
+'<show exec (+f X)[+f=>+g]>
+'<show exec (union #1 #2)
+'  [#1=>[(+f X) X)]]
+'  [#2=>(-f a)]>
 
 'checkers & typechecking
-(def checker (galaxy
-  (interaction (union @#tested #test))
-  (expect (const (star ok)))))
+(:= checker [
+  [+interaction (union @#tested #test)]
+  [+expect ok]])
 
-(spec nat
-  (galaxy
-    (test
-      (const
-        (star (-nat 0) ok)
-        (star (-nat (s N)) (+nat N))))))
+(spec nat [
+  [(-nat 0) ok)]
+  [(-nat (s N)) (+nat N)]])
 
-(:: 0 (nat /checker))
-(def 0
-  (const (star (+nat 0))))
+'(:: 0 (nat | checker))
+'(:= 0 (+nat 0))
 
+'''
 (:: 1 (nat / checker))
 (def 1
   (const (star (+nat (s 0)))))
@@ -114,29 +104,7 @@
 (def 4
   (const (star (+nat <s s s s /0>))))
 
-(interface nat_pair
-  (:: n nat)
-  (:: m nat))
-
-(:: g_pair nat_pair)
-(def g_pair
-  (galaxy
-    (n (const (star (+nat 0))))
-    (m (const (star (+nat 0))))))
-
-'galaxy with type declarations
-(show (galaxy
-  (:: n1 nat)
-  (n1 (const (star (+nat 0))))
-  (:: n2 nat)
-  (n2 (const (star (+nat <s s /0>))))))
-
 'import file
 '(use examples automata)
 
-'complex identifiers
-(def (f a b)
-  (const
-    (star (function a b))))
-(show #(f a b))
 '''

nvim/syntax/stellogen.vim

@@ -1,6 +1,6 @@
 syn clear
 
-syn keyword sgKeyword def kill clean const star show use exec spec linear trace process end galaxy run interface union
+syn keyword sgKeyword kill clean eval show use exec spec linear trace process run union
 syn match sgComment "\s*'[^'].*$"
 syn match sgId "#\%(\l\|\d\)\w*"
 syn region sgComment start="'''" end="'''" contains=NONE
@@ -9,7 +9,9 @@ syn match sgSeparator "[\<\>\{\}\[\]|]"
 syn match sgOperator "@"
 syn match sgOperator "::"
 syn match sgOperator "=="
+syn match sgOperator ":="
 syn match sgOperator "!="
+syn match sgOperator "&"
 
 hi link sgKeyword Keyword
 hi link sgId Identifier

src/expr.ml

@@ -82,7 +82,7 @@ let symbol_of_str (s : string) : idfunc =
 let rec ray_of_expr : expr -> ray = function
   | Symbol s -> to_func ((Muted, symbol_of_str s), [])
   | Var s -> to_var s
-  | Unquote e -> failwith ("error: cannot unquote ray " ^ to_string e)
+  | Unquote e -> to_func ((Muted, (Null, "#")), [ ray_of_expr e ])
   | List [] -> failwith "error: ray cannot be empty"
   | List (Symbol h :: t) ->
     to_func ((Muted, symbol_of_str h), List.map ~f:ray_of_expr t)
@@ -179,10 +179,20 @@ let rec galaxy_expr_of_expr (e : expr) : galaxy_expr =
    Stellogen program of Expr
    --------------------------------------- *)
 
+(* let typedecl_of_expr : expr -> type_declaration = function
+  | Symbol k when equal_string k nil_op -> []
+  | List [ Symbol k; h; t ] when equal_string k cons_op ->
+*)
+
 let decl_of_expr : expr -> declaration = function
   (* definition := *)
   | List [ Symbol k; x; g ] when equal_string k def_op ->
     Def (ray_of_expr x, galaxy_expr_of_expr g)
+  | List [ Symbol k; x; g ] when equal_string k "spec" ->
+    Def (ray_of_expr x, galaxy_expr_of_expr g)
+  (* type declaration :: *)
+  (* | List [ Symbol k; x; g ] when equal_string k typedef_op ->
+    Typedecl (ray_of_expr x, typedecl_of_expr g) *)
   (* show *)
   | List [ Symbol k; g ] when equal_string k "show" ->
     Show (galaxy_expr_of_expr g)
@@ -191,7 +201,7 @@ let decl_of_expr : expr -> declaration = function
     Trace (galaxy_expr_of_expr g)
   (* expect *)
   | List [ Symbol k; x; g ] when equal_string k expect_op ->
-    TypeDef (TExp (ray_of_expr x, galaxy_expr_of_expr g))
+    Expect (ray_of_expr x, galaxy_expr_of_expr g)
   | _ -> failwith "error: invalid declaration"
 
 let program_of_expr = List.map ~f:decl_of_expr

src/sgen_ast.ml

@@ -9,18 +9,9 @@ type idfunc = polarity * string
 
 type ray_prefix = StellarRays.fmark * idfunc
 
-type type_declaration =
-  | TDef of ident * (ident * ident option) list
-  | TExp of ident * galaxy_expr
-
 and galaxy =
   | Const of marked_constellation
-  | Galaxy of galaxy_declaration list
-  | Interface of type_declaration list
-
-and galaxy_declaration =
-  | GTypeDef of type_declaration
-  | GLabelDef of ident * galaxy_expr
+  | Galaxy of (ident * galaxy_expr) list
 
 and galaxy_expr =
   | Raw of galaxy
@@ -54,10 +45,7 @@ type env =
 
 let expect (g : galaxy_expr) : galaxy_expr =
   Raw
-    (Galaxy
-       [ GLabelDef (const "interaction", Id (const "tested"))
-       ; GLabelDef (const "expect", g)
-       ] )
+    (Galaxy [ (const "interaction", Id (const "tested")); (const "expect", g) ])
 
 let initial_env =
   { objs = [ (const "^empty", Raw (Const [])) ]
@@ -69,7 +57,8 @@ type declaration =
   | Show of galaxy_expr
   | Trace of galaxy_expr
   | Run of galaxy_expr
-  | TypeDef of type_declaration
+  | Typedecl of ident * (ident * ident option) list
+  | Expect of ident * galaxy_expr
   | Use of ident list
 
 type program = declaration list