tulisp 0.29.0

An embeddable lisp interpreter.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

#[path = "common/mod.rs"]
mod common;

use std::hint::black_box;
use tulisp::{Error, TulispContext};

const FIB_N: i64 = 25;

const FIB_INT_DEFUN: &str = "(defun fib (n)
  (if (<= n 2)
      1
      (+ (fib (- n 1))
         (fib (- n 2)))))";

const FIB_FLOAT_DEFUN: &str = "(defun fib (n)
  (if (<= n 2.0)
      1.0
      (+ (fib (- n 1.0))
         (fib (- n 2.0)))))";

fn main() -> Result<(), Error> {
    let mut results = Vec::new();

    results.push(common::run("fib_int_tw_full", || {
        let mut ctx = TulispContext::new();
        ctx.tw_eval_string(FIB_INT_DEFUN)?;
        let result: i64 = ctx
            .tw_eval_string(&format!("(fib {})", black_box(FIB_N)))?
            .try_into()?;
        Ok(black_box(result).to_string())
    })?);

    {
        let mut ctx = TulispContext::new();
        ctx.tw_eval_string(FIB_INT_DEFUN)?;
        let program = ctx.tw_eval_string(&format!("'(fib {})", FIB_N))?;
        results.push(common::run("fib_int_tw_call", || {
            let result: i64 = ctx.eval(&program)?.try_into()?;
            Ok(black_box(result).to_string())
        })?);
    }

    results.push(common::run("fib_int_vm_full", || {
        let mut ctx = TulispContext::new();
        ctx.eval_string(FIB_INT_DEFUN)?;
        let result: i64 = ctx
            .eval_string(&format!("(fib {})", black_box(FIB_N)))?
            .try_into()?;
        Ok(black_box(result).to_string())
    })?);

    {
        let mut ctx = TulispContext::new();
        ctx.eval_string(FIB_INT_DEFUN)?;
        let call = format!("(fib {})", FIB_N);
        results.push(common::run("fib_int_vm_call", || {
            let result: i64 = ctx.eval_string(&call)?.try_into()?;
            Ok(black_box(result).to_string())
        })?);
    }

    results.push(common::run("fib_float_tw_full", || {
        let mut ctx = TulispContext::new();
        ctx.tw_eval_string(FIB_FLOAT_DEFUN)?;
        let result: f64 = ctx
            .tw_eval_string(&format!("(fib {})", black_box(FIB_N)))?
            .try_into()?;
        Ok(black_box(result).to_string())
    })?);

    {
        let mut ctx = TulispContext::new();
        ctx.tw_eval_string(FIB_FLOAT_DEFUN)?;
        let program = ctx.tw_eval_string(&format!("'(fib {})", FIB_N))?;
        results.push(common::run("fib_float_tw_call", || {
            let result: f64 = ctx.eval(&program)?.try_into()?;
            Ok(black_box(result).to_string())
        })?);
    }

    results.push(common::run("fib_float_vm_full", || {
        let mut ctx = TulispContext::new();
        ctx.eval_string(FIB_FLOAT_DEFUN)?;
        let result: f64 = ctx
            .eval_string(&format!("(fib {})", black_box(FIB_N)))?
            .try_into()?;
        Ok(black_box(result).to_string())
    })?);

    {
        let mut ctx = TulispContext::new();
        ctx.eval_string(FIB_FLOAT_DEFUN)?;
        let call = format!("(fib {})", FIB_N);
        results.push(common::run("fib_float_vm_call", || {
            let result: f64 = ctx.eval_string(&call)?.try_into()?;
            Ok(black_box(result).to_string())
        })?);
    }

    if let Some(path) = std::env::args().nth(1) {
        common::save_results(&path, &results);
    }
    common::print_summary(&results);
    Ok(())
}