lib-tan-core 0.16.0

The core library
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
161
162

use tan::{
    context::Context,
    error::Error,
    expr::Expr,
    util::{
        args::{unpack_float_arg, unpack_float_range_arg},
        module_util::require_module,
    },
};

// #todo Do we need a separate Interval type?
// #todo Range could be like in Rust and _not_ include a step, instead provide a step_by function?

// #todo #hack No need for Range expressions, this is a temp hack.

// #todo make some fields optional.
// struct ForeignRange<T> {
//     pub start: T,
//     pub end: T,
//     pub step: T,
// }

// #todo Range is Immutable, Copy.

// #todo not used yet.
// fn make_range<T: Send + Sync + 'static>(start: T, end: T, step: T) -> Expr {
//     // #todo use IntRange, FloatRange.
//     let foreign_range = ForeignRange { start, end, step };
//     let expr = Expr::ForeignStruct(Arc::new(foreign_range));
//     // #todo should annotate (Range Int) or (Range Float)
//     annotate_type(expr, "Range")
// }

pub fn range_int_new(args: &[Expr]) -> Result<Expr, Error> {
    // #todo make some of the arguments optional, e.g. step.
    let [start, end, ..] = args else {
        return Err(Error::invalid_arguments(
            "requires `start`, `end` arguments",
            None,
        ));
    };

    // #todo create a helper.
    let Some(start) = start.as_int() else {
        return Err(Error::invalid_arguments(
            &format!("start=`{start}` is not Int"),
            start.range(),
        ));
    };

    let Some(end) = end.as_int() else {
        return Err(Error::invalid_arguments(
            &format!("end=`{end}` is not Int"),
            end.range(),
        ));
    };

    let step = if let Some(step) = args.get(2) {
        let Some(step) = step.as_int() else {
            return Err(Error::invalid_arguments(
                &format!("step=`{step}` is not Int"),
                step.range(),
            ));
        };
        step
    } else if end >= start {
        1
    } else {
        -1
    };

    // #todo use Expr::ForeignStruct
    Ok(Expr::IntRange(start, end, step))
}

pub fn range_float_new(args: &[Expr]) -> Result<Expr, Error> {
    // #todo make some of the arguments optional, e.g. step.
    let [start, end, ..] = args else {
        return Err(Error::invalid_arguments(
            "requires `start`, `end`, and `step` arguments",
            None,
        ));
    };

    // #todo create a helper.
    let Some(start) = start.as_float() else {
        return Err(Error::invalid_arguments(
            &format!("start=`{start}` is not Float"),
            start.range(),
        ));
    };

    let Some(end) = end.as_float() else {
        return Err(Error::invalid_arguments(
            &format!("end=`{end}` is not Float"),
            end.range(),
        ));
    };

    let step = if let Some(step) = args.get(2) {
        let Some(step) = step.as_float() else {
            return Err(Error::invalid_arguments(
                &format!("step=`{step}` is not Float"),
                step.range(),
            ));
        };
        step
    } else if end >= start {
        1.0
    } else {
        -1.0
    };

    // #todo use Expr::ForeignStruct
    Ok(Expr::FloatRange(start, end, step))
}

// #todo Implement those in Tan.

// #todo Add contains.
// #todo Add surrounds.
// #todo Add size/length.
// #todo Constants: empty, universe.
// #todo The name `universe` is weird.

// #todo Support open-ended and close-ended ranges.

// #todo Add unit tests.
// #todo Should take the step into account? Probably yes.
// #todo The term `contains` is a bit ambiguous, could use `includes` or `surrounds`?
// #todo Maybe `surrounds` should be like contains/includes but ignoring the step.
pub fn range_float_contains(args: &[Expr]) -> Result<Expr, Error> {
    let range = unpack_float_range_arg(args, 0, "range")?;
    let value = unpack_float_arg(args, 1, "value")?;
    Ok(Expr::Bool(range.contains(&value)))
}

pub fn setup_lib_range(context: &mut Context) {
    // #todo put in 'range' path, and import selected functionality to prelude.
    let module = require_module("prelude", context);

    module.insert_invocable("Range", Expr::foreign_func(&range_int_new));
    module.insert_invocable("Range$$Int$$Int", Expr::foreign_func(&range_int_new));
    module.insert_invocable("Range$$Int$$Int$$Int", Expr::foreign_func(&range_int_new));
    module.insert_invocable("Range$$Float$$Float", Expr::foreign_func(&range_float_new));
    module.insert_invocable(
        "Range$$Float$$Float$$Float",
        Expr::foreign_func(&range_float_new),
    );

    // #todo Contains should probably take the step into account.
    module.insert_invocable(
        "contains?$$(Range Float)$$Float",
        Expr::foreign_func(&range_float_contains),
    );
    // #todo Find a better name, originally from https://raytracing.github.io/
    module.insert_invocable("surrounds?", Expr::foreign_func(&range_float_contains));
    module.insert_invocable(
        "surrounds?$$(Range Float)$$Float",
        Expr::foreign_func(&range_float_contains),
    );
}