adapt Abstraction variant of LTExpr to allow multiple parameters

This avoids unneccesary recursive chaining and also allows abstractions with zero parameters.

src/expr.rs

@@ -12,6 +12,10 @@ pub enum Statement {
         var_id: String,
         val_expr: LTExpr
     },
+    LetAssign {
+        var_id: String,
+        val_expr: LTExpr,
+    },
     WhileLoop {
         condition: LTExpr,
         body: Vec<Statement>
@@ -23,11 +27,11 @@ pub enum Statement {
 #[derive(Clone, Debug)]
 pub enum LTExpr {
     Literal {
-        typ: laddertypes::TypeTerm,
+        typ: Option< laddertypes::TypeTerm >,
         val: tisc::VM_Word
     },
     Symbol {
-        typ: laddertypes::TypeTerm,
+        typ: Option< laddertypes::TypeTerm >,
         symbol: String,
     },
     Application {
@@ -35,13 +39,7 @@ pub enum LTExpr {
         body: Vec<LTExpr>
     },
     Abstraction {
-        arg_id: String,
-        arg_type: laddertypes::TypeTerm,
-        val_expr: Box<LTExpr>
-    },
-    Let {
-        name: String,
-        val: Box<LTExpr>,
+        args: Vec<(String, Option<laddertypes::TypeTerm>)>,
         body: Box<LTExpr>
     },
     Branch {
@@ -55,33 +53,27 @@ pub enum LTExpr {
 }
 
 impl LTExpr {
-    pub fn symbol(typectx: &Arc<RwLock<laddertypes::TypeDict>>, str: &str) -> Self {
+    pub fn symbol(str: &str) -> Self {
         LTExpr::Symbol {
-            typ: typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
+            typ: None,//typectx.write().unwrap().parse("<Ref memory::Word>~Symbol~<Seq Char>").expect("parse typeterm"),
             symbol: String::from(str)
         }
     }
 
-    pub fn lit_uint(typectx: &Arc<RwLock<laddertypes::TypeDict>>, val: u64) -> Self {
+    pub fn lit_uint(val: u64) -> Self {
         LTExpr::Literal {
-            typ: typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
+            typ: None,//typectx.write().unwrap().parse("ℤ_2^64~machine::UInt64~machine::Word").expect("parse typeterm"),
             val: val as tisc::VM_Word
         }
     }
 
-    pub fn abstraction(typectx: &Arc<RwLock<laddertypes::TypeDict>>, arg_id: &str, arg_typ: &str, val_expr: LTExpr) -> LTExpr {
+    pub fn abstraction(args: Vec<(&str, &str)>, val_expr: LTExpr) -> LTExpr {
         LTExpr::Abstraction {
-            arg_id: String::from(arg_id),
-            arg_type: typectx.write().unwrap().parse(arg_typ).expect("parse typeterm"),
-            val_expr: Box::new(val_expr)
-        }
-    }
-
-    pub fn let_expr(typectx: &Arc<RwLock<laddertypes::TypeDict>>, name: &str, val: LTExpr, body: LTExpr) -> Self {
-        LTExpr::Let {
-            name: String::from(name),
-            val: Box::new(val),
-            body: Box::new(body)
+            args: args.into_iter().map(|(arg_name, arg_type)|
+                ( arg_name.into(), None )    
+                //typectx.write().unwrap().parse(t).expect("parse typeterm")
+            ).collect(),
+            body: Box::new(val_expr)
         }
     }
 

src/lexer.rs

@@ -0,0 +1,186 @@
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub enum LTIRToken {
+    Symbol( String ),
+    Char( char ),
+    Num( i64 ),
+
+    // SingleQuote(String),
+    // DoubleQuote(String),
+    // TripleQuote(String),
+
+    Lambda,
+    AssignType,
+    AssignValue,
+
+    ExprOpen,
+    ExprClose,
+
+    BlockOpen,
+    BlockClose,
+    StatementSep,
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub enum LexError {
+    InvalidDigit,
+    InvalidChar
+}
+
+#[derive(PartialEq, Eq, Clone, Debug)]
+pub enum LexerState {
+    Any,
+    Sym( String ),
+    Num( i64 ),
+    Char( Option<char> )
+}
+
+impl LexerState {
+    fn into_token(self) -> Option< LTIRToken > {
+        match self {
+            LexerState::Any => None,
+            LexerState::Sym(s) => Some(LTIRToken::Symbol(s)),
+            LexerState::Num(n) => Some(LTIRToken::Num(n)),
+            LexerState::Char(c) => Some(LTIRToken::Char(c?))
+        }
+    }
+}
+
+
+pub struct LTIRLexer<It>
+where It: std::iter::Iterator<Item = char>
+{
+    chars: std::iter::Peekable<It>,
+}
+
+impl<It> LTIRLexer<It>
+where It: Iterator<Item = char>
+{
+    pub fn into_inner(self) -> std::iter::Peekable<It> {
+        self.chars
+    }
+}
+
+impl<It> From<It> for LTIRLexer<It>
+where It: Iterator<Item = char>
+{
+    fn from(chars: It) -> Self {
+        LTIRLexer {
+            chars: chars.peekable()
+        }
+    }
+}
+
+impl<It> Iterator for LTIRLexer<It>
+where It: Iterator<Item = char>
+{
+    type Item = Result<LTIRToken, LexError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut state = LexerState::Any;
+
+        while let Some(c) = self.chars.peek() {
+            match &mut state {
+
+                // determine token type
+                LexerState::Any => {
+                    match c {
+                        'λ' => { self.chars.next(); return Some(Ok(LTIRToken::Lambda)); },
+                        '(' => { self.chars.next(); return Some(Ok(LTIRToken::ExprOpen)); },
+                        ')' => { self.chars.next(); return Some(Ok(LTIRToken::ExprClose)); },
+                        '{' => { self.chars.next(); return Some(Ok(LTIRToken::BlockOpen)); },
+                        '}' => { self.chars.next(); return Some(Ok(LTIRToken::BlockClose)); },
+                        ':' => { self.chars.next(); return Some(Ok(LTIRToken::AssignType)); },
+                        '=' => { self.chars.next(); return Some(Ok(LTIRToken::AssignValue)); },
+                        ';' => { self.chars.next(); return Some(Ok(LTIRToken::StatementSep)); },
+                        '\'' => { self.chars.next(); state = LexerState::Char(None); },
+                        c => {
+                            if c.is_whitespace() {
+                                self.chars.next();
+                            } else if c.is_digit(10) {
+                                state = LexerState::Num( 0 );
+                            } else {
+                                state = LexerState::Sym( String::new() );
+                            }
+                        }
+                    }
+                }
+
+                LexerState::Char(val) => {
+                    *val = Some(
+                        match self.chars.next() {
+                            Some('\\') => {
+                                match self.chars.next() {
+                                    Some('0') => '\0',
+                                    Some('n') => '\n',
+                                    Some('t') => '\t',
+                                    Some(c) => c,
+                                    None => {
+                                        return Some(Err(LexError::InvalidChar));
+                                    }
+                                }
+                            }
+                            Some(c) => c,
+                            None => {
+                                return Some(Err(LexError::InvalidChar));
+                            }
+                        });
+
+                    match self.chars.next() {
+                        Some('\'') => {
+                            if let Some(token) = state.clone().into_token() {
+                                return Some(Ok(token));
+                            }                            
+                        }
+                        _ => {
+                            return Some(Err(LexError::InvalidChar));
+                        }
+                    }
+                }
+
+                _ => {
+
+                    if c.is_whitespace()
+                        || *c == '(' || *c == ')'
+                        || *c == '{' || *c == '}'
+                        || *c == ';' || *c == '=' || *c == ':'
+                    {
+                        // finish the current token
+
+                        if let Some(token) = state.clone().into_token() {
+                            return Some(Ok(token));
+                        }
+                    } else {
+                        // append to the current token
+
+                        let c = self.chars.next().unwrap();
+
+                        match &mut state {
+                            LexerState::Sym(s) => {
+                                s.push(c);
+                            }
+
+                            LexerState::Num(n) => {
+                                if let Some(d) = c.to_digit(10) {
+                                    *n = (*n) * 10 + d as i64;
+                                } else {
+                                    return Some(Err(LexError::InvalidDigit));
+                                }
+                            }
+
+                            _ => {}
+                        }
+                    }
+                }
+            }
+        }
+
+        if let Some(token) = state.into_token() {
+            Some(Ok(token))
+        } else {
+            None
+        }
+    }
+}
+
+

src/main.rs

@@ -8,6 +8,8 @@ mod expr;
 mod symbols;
 mod procedure_compiler;
 mod runtime;
+mod lexer;
+mod parser;
 
 use crate::{
     expr::{LTExpr, Statement},
@@ -15,6 +17,18 @@ use crate::{
     procedure_compiler::ProcedureCompiler
 };
 
+fn compile(scope: &Arc<RwLock<Scope>>, name: &str, source: &str) -> Vec< tisc::assembler::AssemblyWord > {
+    ProcedureCompiler::new(scope)
+        .compile(
+            &parser::parse_expr(
+                &mut lexer::LTIRLexer::from(
+                    source.chars().peekable()
+                ).peekable()
+            ).expect("syntax error")
+        )
+        .into_asm(&name.into())
+}
+
 fn main() {
     // create virtual machine with 4096 words of memory
     let mut vm = tisc::VM::new(0x1000);
@@ -22,7 +36,6 @@ fn main() {
     let mut linker = tisc::Linker::new();
     let root_scope = crate::runtime::init_runtime(&mut linker);
     let main_scope = Scope::with_parent(&root_scope);
-
     let typectx = main_scope.read().unwrap().typectx.clone();
 
     /* define type of the symbol
@@ -37,70 +50,53 @@ fn main() {
         );
 
     main_scope.write().unwrap()
-        .declare_proc_parse(
-            "print-nullterm",
-        vec![],
-        vec![
-            "<Ref <Seq Char~Ascii~machine::Word>~<NullTerminatedSeq machine::Word>>
-            ~machine::Address
-            ~machine::Word"
-        ],
-        vec![]);
+        .declare_static_parse(
+            "pfxstr",
+            "<Seq Char
+                  ~Ascii
+                  ~machine::Word>
+             ~<LengthPrefixedSeq machine::Word>"
+        );
 
-    /* link assembly-program to symbol
+    /* link assembly-program to symbols
      */
-    linker.add_procedure(
+    linker.add_procedure("main", compile(&main_scope,
         "main",
-        ProcedureCompiler::new(&main_scope)
-            .compile(
-                &LTExpr::block(vec![
-                    Statement::Expr(
-                        LTExpr::application(
-                            LTExpr::abstraction(
-                                &typectx,
-                                "c",
-                                "Char",
-                                LTExpr::block(vec![
-                                    Statement::Expr(LTExpr::application(
-                                        LTExpr::symbol(&typectx, "emit"),
-                                        vec![
-                                            LTExpr::symbol(&typectx, "c")
-                                        ]
-                                    )),
-                                    Statement::Assignment{
-                                        var_id: "c".into(),
-                                        val_expr: LTExpr::application(
-                                            LTExpr::symbol(&typectx, "i+"),
-                                            vec![
-                                                LTExpr::symbol(&typectx, "c"),
-                                                LTExpr::lit_uint(&typectx, 1)
-                                            ]
-                                        )
-                                    },
-                                    Statement::Expr(LTExpr::application(
-                                        LTExpr::symbol(&typectx, "emit"),
-                                        vec![
-                                            LTExpr::symbol(&typectx, "c")
-                                        ]
-                                    ))
-                                ])
-                            ),
-                            vec![
-                                LTExpr::lit_uint(&typectx, 42)
-                            ]
-                        )),
-                    Statement::Expr(
-                        LTExpr::application(
-                            LTExpr::symbol(&typectx, "emit"),
-                            vec![
-                                LTExpr::lit_uint(&typectx, 10)
-                            ]
-                        ))
-                ])
-            )
-            .into_asm()
-            .build()
-    );
+        "{
+            let print-nullterm = λstr {
+                while (@ str) {
+                    emit (@ str);
+                    ! str (i+ str 1);
+                }
+            };
+
+            let print-lenprefix = λstr {
+                let len = (@ str);
+                ! str (i+ str 1);
+                let end = (i+ str len);
+                while (i- str end) {
+                    emit (@ str);
+                    ! str (i+ str 1);
+                }
+            };
+
+            let hello = λ{
+                print-nullterm hello-string;
+                print-lenprefix pfxstr;
+            };
+
+            hello;
+
+            let isquare = λx (i* x x);
+            let magnitude2 = λx y {
+                i+ (isquare x) (isquare y);
+            };
+            magnitude2 8 16;
+
+            emit '\n';
+            emit (i+ '0' (isquare 3));
+            emit '\n';
+        }"));
 
     linker.add_static("hello-string",
         "Hallo Welt!\n\0"
@@ -108,66 +104,8 @@ fn main() {
             .map(|c| (c as u8) as tisc::VM_Word)
             .collect());
 
-    linker.add_procedure(
-        "print-nullterm",
-        tisc::Assembler::new()
-            .while_loop(
-                tisc::Assembler::new()
-                    .inst( tisc::VM_Instruction::Dup )
-                    .inst( tisc::VM_Instruction::Fetch )
-                    .inst( tisc::VM_Instruction::Dup ),
-
-                tisc::Assembler::new()
-                    .inst( tisc::VM_Instruction::Emit )
-                    .lit( 1 )
-                    .inst( tisc::VM_Instruction::Add )
-            )
-            .inst( tisc::VM_Instruction::Drop )
-            .inst( tisc::VM_Instruction::Drop )
-            .build()
-    );
-
-    main_scope.write().unwrap().declare_proc_parse(
-        "print-lenprefix",
-        vec![],
-        vec![
-            "<Ref <Seq Char~Ascii~machine::Word>~<LengthPrefixedSeq machine::Word>>
-            ~machine::Address
-            ~machine::Word"
-        ],
-        vec![]);
-
-    linker.add_procedure(
-        "print-lenprefix",
-        tisc::Assembler::new()
-            // calculate stop address
-            .inst( tisc::VM_Instruction::Dup )
-            .inst( tisc::VM_Instruction::Dup )
-            .inst( tisc::VM_Instruction::Fetch )
-            .lit(1)
-            .inst( tisc::VM_Instruction::Add )
-            .inst( tisc::VM_Instruction::Add )
-            .inst( tisc::VM_Instruction::Swap )
-
-            // emit until address == start address
-            .while_loop(
-                tisc::Assembler::new()
-                    .lit( 2 )
-                    .inst( tisc::VM_Instruction::Pick )
-                    .lit( 2 )
-                    .inst( tisc::VM_Instruction::Pick )
-                    .call("i-"),
-
-                tisc::Assembler::new()
-                    .inst( tisc::VM_Instruction::Dup )
-                    .inst( tisc::VM_Instruction::Fetch )
-                    .inst( tisc::VM_Instruction::Emit )
-                    .lit( 1 )
-                    .inst( tisc::VM_Instruction::Add )
-            )
-            .inst( tisc::VM_Instruction::Drop )
-            .inst( tisc::VM_Instruction::Drop )
-            .build()
+    linker.add_static("pfxstr",
+        vec![ 3, 'a' as tisc::VM_Word, 'b' as tisc::VM_Word, 'c' as tisc::VM_Word, 'd' as tisc::VM_Word ]
     );
 
     let main_addr = linker.get_link_addr(&"main".into()).expect("'main' not linked"); 

src/parser.rs

@@ -0,0 +1,255 @@
+use {
+    std::iter::Peekable,
+    crate::{
+        lexer::{LTIRLexer, LTIRToken, LexError},
+        expr::{LTExpr, Statement}
+    }
+};
+
+#[derive(Clone, Debug)]
+pub enum ParseError {
+    LexError(LexError),
+    UnexpectedClose,
+    UnexpectedEnd,
+    UnexpectedToken
+}
+
+pub fn parse_expect<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>,
+    expected_token: LTIRToken
+) -> Result< (), ParseError >
+where It: Iterator<Item = char>
+{
+    match tokens.next() {
+        Some(Ok(t)) => {
+            if t == expected_token {
+                Ok(())
+            } else {
+                Err(ParseError::UnexpectedToken)
+            }
+        },
+        Some(Err(err)) => Err(ParseError::LexError(err)),
+        None => Err(ParseError::UnexpectedEnd)
+    }
+}
+
+pub fn parse_symbol<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>
+) -> Result< String, ParseError >
+where It: Iterator<Item = char>
+{
+    match tokens.next() {
+        Some(Ok(LTIRToken::Symbol(name))) => Ok(name),
+        Some(Ok(_)) => Err(ParseError::UnexpectedToken),
+        Some(Err(err)) => Err(ParseError::LexError(err)),
+        None => Err(ParseError::UnexpectedEnd),
+    }
+}
+
+pub fn parse_statement<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>
+) -> Result< crate::expr::Statement, ParseError >
+where It: Iterator<Item = char>
+{
+    if let Some(peektok) = tokens.peek() {
+        match peektok {
+            Ok(LTIRToken::Symbol(sym)) => {
+                match sym.as_str() {
+                    "!" => {
+                        tokens.next();
+                        // todo accept address-expression instead of symbol
+                        let name = parse_symbol(tokens)?;
+                        let val_expr = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
+
+                        Ok(Statement::Assignment {
+                            var_id: name,
+                            val_expr
+                        })
+                    }
+                    "let" => {
+                        tokens.next();
+                        let name = parse_symbol(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::AssignValue);
+                        let val_expr = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
+
+                        Ok(Statement::LetAssign {
+                            var_id: name,
+                            val_expr
+                        })
+                    }
+                    "while" => {
+                        tokens.next();
+                        let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
+                        let cond = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
+                        Ok(Statement::WhileLoop {
+                            condition: cond,
+                            body: parse_block(tokens)?
+                        })
+                    }
+                    "return" => {
+                        tokens.next();
+                        let expr = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
+                        Ok(Statement::Return(parse_expr(tokens)?))
+                    }
+                    _ => {
+                        let expr = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
+                        Ok(Statement::Expr(expr))
+                    }
+                }
+            }
+            Ok(_) => {
+                let expr = parse_expr(tokens)?;
+                let _ = parse_expect(tokens, LTIRToken::StatementSep)?;
+                Ok(Statement::Expr(expr))
+            },
+            Err(err) => Err(ParseError::LexError(err.clone()))
+        }
+    } else {
+        Err(ParseError::UnexpectedEnd)
+    }
+}
+
+pub fn parse_block<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>
+) -> Result< Vec<Statement>, ParseError >
+where It: Iterator<Item = char>
+{
+    let _ = parse_expect(tokens, LTIRToken::BlockOpen)?;
+
+    let mut statements = Vec::new();
+    while let Some(peektok) = tokens.peek() {
+        match peektok {
+            Ok(LTIRToken::BlockClose) => {
+                tokens.next();
+                return Ok(statements)
+            }
+            Ok(_) => { statements.push( parse_statement(tokens)? ); }
+            Err(err) => { return Err(ParseError::LexError(err.clone())); }
+        }
+    }
+
+    Err(ParseError::UnexpectedEnd)
+}
+
+pub fn parse_atom<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>
+) -> Result< crate::expr::LTExpr, ParseError >
+where It: Iterator<Item = char>
+{
+    match tokens.next() {
+        Some(Ok(LTIRToken::Symbol(sym))) => {
+            Ok(LTExpr::symbol(sym.as_str()))
+        }
+        Some(Ok(LTIRToken::Char(c))) => {
+            Ok(LTExpr::lit_uint(c as u64))
+        }
+        Some(Ok(LTIRToken::Num(n))) => {
+            Ok(LTExpr::lit_uint(n as u64))
+        }
+        Some(Ok(_)) => {
+            Err(ParseError::UnexpectedToken)
+        }
+        Some(Err(err)) => {
+            Err(ParseError::LexError(err))
+        }
+        None => {
+            Err(ParseError::UnexpectedEnd)
+        }
+    }
+}
+
+pub fn parse_expr<It>(
+    tokens: &mut Peekable<LTIRLexer<It>>
+) -> Result< crate::expr::LTExpr, ParseError >
+where It: Iterator<Item = char>
+{
+    let mut children = Vec::new();
+
+    while let Some(tok) = tokens.peek() {
+        match tok {
+            Ok(LTIRToken::Lambda) => {
+                if children.len() == 0 {
+                    tokens.next();
+
+                    let mut args = Vec::new();
+                    while let Some(Ok(LTIRToken::Symbol(_))) = tokens.peek() {
+                        args.push((parse_symbol(tokens)?, None));
+                    }
+                    let body = parse_expr(tokens)?;
+
+                    return Ok(LTExpr::Abstraction{
+                        args,
+                        body: Box::new(body)
+                    });
+                } else {
+                    return Err(ParseError::UnexpectedToken);
+                }
+            }
+            Ok(LTIRToken::ExprOpen) => {
+                tokens.next();
+                while let Some(peektok) = tokens.peek() {
+                    match peektok {
+                        Ok(LTIRToken::ExprClose) => {
+                            tokens.next();
+                            break;
+                        }
+                        _ => {}
+                    }
+                    children.push(parse_expr(tokens)?);
+                }
+            },
+            Ok(LTIRToken::ExprClose) => { break; }
+            Ok(LTIRToken::BlockOpen) => { children.push( LTExpr::block(parse_block(tokens)?)); }
+            Ok(LTIRToken::BlockClose) => { break; }
+            Ok(LTIRToken::StatementSep) => { break; }
+            Ok(LTIRToken::Symbol(name)) => {
+                match name.as_str() {
+                    "if" => {
+                        tokens.next();
+                        let _ = parse_expect(tokens, LTIRToken::ExprOpen)?;
+                        let cond = parse_expr(tokens)?;
+                        let _ = parse_expect(tokens, LTIRToken::ExprClose)?;
+                        let if_expr = LTExpr::block(parse_block(tokens)?);
+                        let mut else_expr = LTExpr::block(vec![]);
+
+                        if let Some(peektok) = tokens.peek() {
+                            if let Ok(LTIRToken::Symbol(name)) = peektok {
+                                if name == "else" {
+                                    tokens.next();
+                                    else_expr = parse_expr(tokens)?;
+                                }
+                            }
+                        }
+
+                        children.push(LTExpr::Branch{
+                            condition: Box::new(cond),
+                            if_expr: Box::new(if_expr),
+                            else_expr: Box::new(else_expr)
+                        });
+                    }
+                    name => {
+                        children.push(parse_atom(tokens)?);
+                    }
+                }
+            }
+            Ok(atom) => { children.push(parse_atom(tokens)?); }
+            Err(err) => { return Err(ParseError::LexError(err.clone())); }
+        }
+    }
+
+    if children.len() > 0 {
+        let head = children.remove(0);
+        Ok(LTExpr::Application {
+            head: Box::new(head),
+            body: children
+        })
+    } else {
+        Err(ParseError::UnexpectedEnd)
+    }
+}
+

src/procedure_compiler.rs

@@ -4,6 +4,10 @@ use {
         sync::{Arc, RwLock},
         ops::Deref,
     },
+    tisc::{
+        assembler::AssemblyWord,
+        linker::LinkAddr
+    },
     crate::{
         expr::{LTExpr, Statement},
         symbols::{Scope, SymbolDef}
@@ -27,14 +31,41 @@ impl ProcedureCompiler {
         }
     }
 
-    pub fn into_asm(self) -> tisc::Assembler {
+    pub fn into_asm(mut self, proc_symbol: &String) -> Vec< tisc::assembler::AssemblyWord > {
         let data_frame_size = self.symbols.read().unwrap().get_frame_size() as i64;
-        tisc::Assembler::new()
-            .lit(data_frame_size)
-            .call("data-frame-alloc")
-            .join(self.asm)
-            .lit(data_frame_size)
-            .call("data-frame-drop")
+
+        let body = self.asm.build();
+        self.linker.add_procedure("__procedure_body__", body);
+        let body_addr = self.linker.get_link_addr(&"__procedure_body__".into()).unwrap();
+        let subroutines = self.linker.link_relative(&"__subroutines__".into()).expect("link error");
+
+        let mut entry = tisc::Assembler::new();
+        if data_frame_size > 0 {
+            entry = entry
+                .lit(data_frame_size)
+                .call("data-frame-alloc");
+        }
+        entry = entry
+            .call_symbol( LinkAddr::Relative{ symbol: "__subroutines__".into(), offset: body_addr });
+
+        if data_frame_size > 0 {
+            entry = entry
+                .lit(data_frame_size)
+                .call("data-frame-drop");
+        }
+
+        let mut superlink = tisc::Linker::new();
+        superlink.add_procedure("", entry.build());
+        superlink.add_procedure("__subroutines__", subroutines);
+
+        let bytecode = superlink.link_relative(proc_symbol).expect("link error");
+/*
+        eprintln!("\n\n{}:", proc_symbol);
+        for (i,w) in tisc::assembler::disassemble(&bytecode).iter().enumerate() {
+            eprintln!("{}:\t\t{}", i, w);
+        }
+*/
+        bytecode
     }
 
     pub fn verify(&self) {
@@ -45,6 +76,7 @@ impl ProcedureCompiler {
         match statement {
             Statement::Assignment{ var_id, val_expr } => {
                 self = self.compile(val_expr);
+
                 match self.symbols.read().unwrap().get(var_id) {
                     Some(SymbolDef::FrameRef{ typ, stack_ref }) => {
                         self.asm = self.asm
@@ -66,6 +98,39 @@ impl ProcedureCompiler {
                     }
                 }
             }
+            Statement::LetAssign{ var_id, val_expr } => { 
+                match val_expr {
+                    LTExpr::Abstraction { args:_, body:_ } => {
+                        self.symbols.write().unwrap()
+                            .declare_proc(
+                                var_id.clone(),
+                                vec![],vec![]
+                        );
+                        let lambda_procedure =
+                            ProcedureCompiler::new(&self.symbols)
+                                .compile( val_expr )
+                                .into_asm( var_id );
+
+                        self.linker.add_procedure(
+                            var_id,
+                            lambda_procedure
+                        );
+                    }
+                    _ => {
+                        self.symbols.write().unwrap()
+                            .declare_var(
+                                var_id.clone(),
+                                laddertypes::TypeTerm::unit()
+                            );
+                        self = self.compile_statement(
+                            &Statement::Assignment {
+                                var_id: var_id.clone(),
+                                val_expr: val_expr.clone()
+                            }
+                        );
+                    }
+                }
+            }
             Statement::WhileLoop { condition, body } => {
                 let asm = self.asm;
 
@@ -111,7 +176,7 @@ impl ProcedureCompiler {
                         eprintln!("undefined symbol '{}'!", symbol);
                     }
                 }
-            },
+            }
             LTExpr::Literal { typ, val } => {
                 self.asm = self.asm.lit( *val );
             }
@@ -120,35 +185,22 @@ impl ProcedureCompiler {
                     self = self.compile(arg);
                 }
                 self = self.compile(head);
-            },
-            LTExpr::Let { name, val, body } => {
-                self.symbols.write().unwrap()
-                    .declare_var(
-                        name.clone(),
-                        laddertypes::TypeTerm::unit()
-                    );
-
-                self = self.compile_statement(
-                    &Statement::Assignment {
-                        var_id: name.clone(),
-                        val_expr: val.deref().clone()
-                    }
-                );
-                self = self.compile(&body.deref().clone());
-            },
-            LTExpr::Abstraction { arg_id: arg_name, arg_type, val_expr } => {
-                let id = self.symbols
-                    .write().unwrap()
-                    .declare_var(
-                        arg_name.clone(),
-                        laddertypes::TypeTerm::unit());
-
-                self.asm = self.asm
-                    .lit( id )
-                    .call("data-frame-set");
-
-                self = self.compile(val_expr);
-            },
+            }
+            LTExpr::Abstraction { args, body } => {
+                for (arg_name, arg_type) in args.iter() {
+                    let id = self.symbols
+                       .write().unwrap()
+                       .declare_var(
+                            arg_name.clone(),
+                            arg_type.clone().unwrap_or(
+                            laddertypes::TypeTerm::unit())
+                        );
+                    self.asm = self.asm
+                        .lit( id )
+                        .call("data-frame-set");
+                }
+                self = self.compile(body);
+            }
             LTExpr::Branch { condition, if_expr, else_expr } => {
                 self = self.compile(condition);
 

src/runtime.rs

@@ -193,38 +193,6 @@ pub fn init_runtime(linker: &mut Linker) -> Arc<RwLock<Scope>> {
             .build()
     );
 
-
-    /*
-     *  let isquare = λx.(i* x x);
-     */
-    symbols.write().unwrap().declare_proc_parse(
-        "isquare",
-        vec![],
-        vec![ "ℤ_2^64~machine::UInt64~machine::Word" ],
-        vec![ "ℤ_2^64~machine::UInt64~machine::Word" ]);
-
-    linker.add_procedure(
-        "isquare",
-        ProcedureCompiler::new(&symbols)
-            .compile(
-                &LTExpr::abstraction(
-                    &typectx,
-                    "x",
-                    "ℤ_2^64~machine::UInt64~machine::Word",
-
-                    LTExpr::application(
-                        LTExpr::symbol(&typectx, "i*"),
-                        vec![
-                           LTExpr::symbol(&typectx, "x"),
-                           LTExpr::symbol(&typectx, "x")
-                        ]
-                    )
-                )
-            )
-            .into_asm()
-            .build()
-    );
-
     symbols.write().unwrap().declare_static_parse(
         "data-frame-ptr",
         "<MutRef <Seq machine::Word>>~machine::Address~machine::Word"