poco-scheme 0.0.1

A toy Scheme implementation
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use std::io::{self, Write};

use crate::Value;

fn invalid_argument(arg: Value, expected: &str) -> Value {
    make_error!("invalid argument, expected {}", expected; arg)
}

fn too_few_arguments(procedure: &str, args: &[Value]) -> Value {
    make_error!("too few arguments to `{}'", procedure; Value::list(args.iter().cloned()))
}

fn wrong_number_of_arguments(procedure: &str, expected: usize, args: &[Value]) -> Value {
    make_error!(
        "wrong number of arguments to `{}': expected {}, got {}",
        procedure,
        expected,
        args.len();
        Value::list(args.iter().cloned())
    )
}

fn io_error(e: io::Error) -> Value {
    make_error!("I/O error: {}", e)
}

fn arithmetic_overflow(operation: &str, arg1: isize, arg2: isize) -> Value {
    make_error!(
        "arithmetic overflow in {} of {} and {}",
        operation,
        arg1,
        arg2
    )
}

fn fixnum_arg(value: &Value) -> Result<isize, Value> {
    value
        .as_fixnum()
        .ok_or_else(|| invalid_argument(value.clone(), "fixnum"))
}

pub fn plus(args: &[Value]) -> Value {
    if let Some((first, rest)) = args.split_first() {
        let mut sum = try_result!(fixnum_arg(first));
        for elt in rest {
            let n = try_result!(fixnum_arg(elt));
            sum = try_result!(sum
                .checked_add(n)
                .ok_or_else(|| arithmetic_overflow("addition", sum, n)));
        }
        Value::Fixnum(sum)
    } else {
        Value::number(0isize)
    }
}

pub fn minus(args: &[Value]) -> Value {
    if let Some((first, rest)) = args.split_first() {
        let mut sum = try_result!(fixnum_arg(first));
        for elt in rest {
            let n = try_result!(fixnum_arg(elt));
            sum = try_result!(sum
                .checked_sub(n)
                .ok_or_else(|| arithmetic_overflow("addition", sum, n)));
        }
        Value::Fixnum(sum)
    } else {
        too_few_arguments("-", args)
    }
}

pub fn times(args: &[Value]) -> Value {
    if let Some((first, rest)) = args.split_first() {
        let mut product = try_result!(fixnum_arg(first));
        for elt in rest {
            let n = try_result!(fixnum_arg(elt));
            product = try_result!(product.checked_mul(n).ok_or_else(|| arithmetic_overflow(
                "multiplication",
                product,
                n
            )));
        }
        Value::Fixnum(product)
    } else {
        Value::Fixnum(1)
    }
}

fn num_cmp<F>(args: &[Value], cmp: F) -> Value
where
    F: Fn(&isize, &isize) -> bool,
{
    // TODO: this does the fixnum conversion more often than necessary, since
    // the windows overlap.
    for w in args.windows(2) {
        let n1 = try_result!(fixnum_arg(&w[0]));
        let n2 = try_result!(fixnum_arg(&w[1]));
        if !cmp(&n1, &n2) {
            return Value::from(false);
        }
    }
    Value::from(true)
}

pub fn eq(args: &[Value]) -> Value {
    num_cmp(args, isize::ge)
}

pub fn lt(args: &[Value]) -> Value {
    num_cmp(args, isize::lt)
}

pub fn le(args: &[Value]) -> Value {
    num_cmp(args, isize::le)
}

pub fn gt(args: &[Value]) -> Value {
    num_cmp(args, isize::gt)
}

pub fn ge(args: &[Value]) -> Value {
    num_cmp(args, isize::ge)
}

pub fn modulo(args: &[Value]) -> Value {
    if args.len() != 2 {
        return wrong_number_of_arguments("mod", 2, args);
    }
    let n1 = try_result!(fixnum_arg(&args[0]));
    let n2 = try_result!(fixnum_arg(&args[1]));
    Value::Fixnum(n1 % n2)
}

pub fn sqrt(args: &[Value]) -> Value {
    if args.len() != 1 {
        return wrong_number_of_arguments("sqrt", 1, args);
    }
    let n = try_result!(fixnum_arg(&args[0]));
    Value::Fixnum((n as f64).sqrt() as isize)
}

pub fn display(args: &[Value]) -> Value {
    if args.len() != 1 {
        // TODO: support ports
        return wrong_number_of_arguments("display", 1, args);
    }
    // TODO: we use the `Display` trait of `Value` here, which currently
    // uses `write` notation, not `display` notation.
    try_result!(write!(io::stdout(), "{}", args[0]).map_err(io_error));
    Value::Unspecified
}

pub fn newline(args: &[Value]) -> Value {
    if !args.is_empty() {
        // TODO: support ports
        return wrong_number_of_arguments("newline", 0, args);
    }
    try_result!(writeln!(io::stdout()).map_err(io_error));
    Value::Unspecified
}