lambda and if-number }:3

runtime/src/gyehoek.rs

@@ -1,6 +1,6 @@
 use wasmtime::*;
 use crate::internal as scm;
-use crate::internal::{Scm,Immediate};
+use crate::internal::{Scm,Immediate,HeapObject};
 
 // pub fn small_fixnum_p (_)
 
@@ -16,13 +16,20 @@ fn write_immediate (_caller : Caller<'_, u32>, imm : Immediate) {
 }
 
 pub fn write (caller : Caller<'_, u32>, x : Rooted<EqRef>) {
-    match scm::interpret (&caller, x).unwrap () {
-        Scm::Immediate (x) => write_immediate (caller, x)
+    match scm::interpret (&caller, x).unwrap ().unwrap () {
+        Scm::Immediate (x) => write_immediate (caller, x),
+        Scm::HeapObject (x) => write_heap_object (caller, x),
+    }
+}
+
+fn write_heap_object (_caller : Caller<'_, u32>, x : HeapObject) {
+    match x {
+        HeapObject::Procedure => print! ("#<procedure>"),
     }
 }
 
 pub fn truthy_p (caller : Caller<'_, u32>, x : Rooted<EqRef>,) -> u32 {
-    let r = scm::interpret (&caller, x).unwrap ();
+    let r = scm::interpret (&caller, x).unwrap ().unwrap ();
     if let Scm::Immediate (Immediate::Bool (false)) = r {
         0
     } else {

runtime/src/internal.rs

@@ -1,4 +1,5 @@
 use wasmtime::*;
+use crate::types;
 
 pub fn immediate_p (store : impl AsContext, x : Rooted<EqRef>) -> bool {
     x.is_i31 (store).unwrap ()
@@ -9,8 +10,13 @@ pub enum Immediate {
     Bool (bool),
 }
 
+pub enum HeapObject {
+    Procedure
+}
+
 pub enum Scm {
     Immediate (Immediate),
+    HeapObject (HeapObject),
 }
 
 #[allow(nonstandard_style)]
@@ -33,14 +39,34 @@ pub fn interpret_immediate (x : scm_bits) -> Option<Immediate> {
     }
 }
 
-pub fn interpret (store : impl AsContext, x : Rooted<EqRef>) -> Option<Scm> {
-    if let Some (imm) = x.as_i31 (store).unwrap () {
-        Some (Scm::Immediate (interpret_immediate (imm.get_u32 ())?))
+pub fn interpret_heap_object (
+    store : impl AsContext,
+    x : Rooted<EqRef>
+) -> Result<Option<HeapObject>> {
+    if x.matches_ty (&store, &types::closure (&store)?)? {
+        Ok (Some (HeapObject::Procedure))
     } else {
         todo! ()
     }
 }
 
+pub fn interpret (
+    store : impl AsContext,
+    x : Rooted<EqRef>
+) -> Result<Option<Scm>> {
+    if let Some (imm) = x.as_i31 (&store)? {
+        Ok (
+            interpret_immediate (imm.get_u32 ())
+                .map (Scm::Immediate)
+        )
+    } else {
+        Ok (
+            interpret_heap_object (&store, x)?
+                .map (Scm::HeapObject)
+        )
+    }
+}
+
 pub fn encode_immediate (
     store : impl AsContext,
     imm : Immediate
@@ -60,6 +86,9 @@ pub fn encode (store : impl AsContextMut, x : Scm) -> Rooted<EqRef> {
                 .unwrap ();
             EqRef::from_i31 (store, i31)
         }
+        Scm::HeapObject (ho) => {
+            todo! ()
+        }
     }
 }
 

runtime/src/main.rs

@@ -1,5 +1,6 @@
 mod gyehoek;
 mod internal;
+mod types;
 
 use std::io;
 use std::io::Read;
@@ -33,7 +34,7 @@ fn get_config () -> Config {
 
 fn link_primitives (linker : &mut Linker<u32>) -> wasmtime::Result<()> {
     linker.func_wrap ("gyehoek", "write", gyehoek::write)?;
-    linker.func_wrap ("gyehoek", "to-bool", gyehoek::truthy_p)?;
+    linker.func_wrap ("gyehoek", "truthy?", gyehoek::truthy_p)?;
     Ok (())
 }
 

runtime/src/types.rs

@@ -0,0 +1,62 @@
+use wasmtime::*;
+use memoize::memoize;
+
+pub fn heap_object_struct (store : impl AsContext) -> Result<StructType> {
+    let ctx = store.as_context ();
+    let engine = ctx.engine ();
+    Ok (
+        StructType::with_finality_and_supertype (
+            engine,
+            Finality::NonFinal,
+            None,
+            vec![
+                hash_field ()
+            ]
+        )?
+    )
+}
+
+pub fn heap_object (_store : impl AsContext) -> Result<HeapType> {
+    todo! ()
+}
+
+#[memoize]
+pub fn hash_field () -> FieldType {
+    FieldType::new (
+        Mutability::Var,
+        StorageType::ValType (ValType::I32)
+    )
+}
+
+pub fn closure (store : impl AsContext) -> Result<HeapType> {
+    let ctx = store.as_context ();
+    let engine = ctx.engine ();
+    Ok (
+        HeapType::ConcreteStruct (
+            StructType::with_finality_and_supertype (
+                engine,
+                Finality::NonFinal,
+                Some (&heap_object_struct (&store)?),
+                vec![
+                    hash_field (),
+                    FieldType::new (
+                        Mutability::Const,
+                        StorageType::ValType (ValType::Ref (
+                            RefType::new (
+                                false,
+                                HeapType::ConcreteFunc (
+                                    FuncType::new (
+                                        engine,
+                                        vec![ValType::I32],
+                                        vec![],
+                                    )
+                                )
+                            )
+                        ))
+                    ),
+                ]
+            )?
+        )
+    )
+}
+