wolfram-expr 0.6.0-alpha.2

Efficient and ergonomic representation of Wolfram expressions in Rust
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

//! `expr!` symbol syntax: symbols are always fully qualified via `::` (each `::`
//! becomes a context backtick); a bare ident is always a Rust variable.

use wolfram_expr::{expr, Expr, ExprKind, Symbol};

fn head(e: &Expr) -> String {
    let ExprKind::Normal(n) = e.kind() else {
        panic!("expected Normal, got {:?}", e);
    };
    let ExprKind::Symbol(s) = n.head().kind() else {
        panic!("expected Symbol head, got {:?}", n.head());
    };
    s.as_str().to_string()
}

#[test]
fn context_qualified_head() {
    let ba = Expr::from(vec![1u8, 2, 3]);
    let e = expr!(Tabular::Arrow::ReadArrowIPCByteArray[ba]);
    assert_eq!(head(&e), "Tabular`Arrow`ReadArrowIPCByteArray");
}

#[test]
fn system_qualified_head() {
    let e = expr!(System::List[1, 2, 3]);
    assert_eq!(head(&e), "System`List");
    let ExprKind::Normal(n) = e.kind() else { panic!("expected Normal") };
    assert_eq!(n.elements().len(), 3);
}

#[test]
fn bare_ident_head_is_a_variable() {
    // A bare ident head is the Rust variable itself, not a `System`` symbol.
    let f = Symbol::new("Global`f");
    let e = expr!(f[1, 2]);
    assert_eq!(head(&e), "Global`f");
}

#[test]
fn bare_symbol_value() {
    let e = expr!(System::InputForm);
    let ExprKind::Symbol(s) = e.kind() else { panic!("expected Symbol") };
    assert_eq!(s.as_str(), "System`InputForm");
}

#[test]
fn context_less_symbol_via_leading_colons() {
    // `::Name` is the context-less symbol `Name` (no context prefix).
    let e = expr!(::Plus);
    let ExprKind::Symbol(s) = e.kind() else { panic!("expected Symbol") };
    assert_eq!(s.as_str(), "Plus");

    // …and as a head: `::List[1, 2]` -> the bare `List` applied to args.
    let call = expr!(::List[1, 2]);
    assert_eq!(head(&call), "List");
    let ExprKind::Normal(n) = call.kind() else { panic!("expected Normal") };
    assert_eq!(n.elements().len(), 2);
}

#[test]
fn nested_qualified_call_mixed_with_variable_and_string() {
    // anything without `::` is a local variable; with `::` it's a symbol.
    let something = Expr::from(42i64);
    let e = expr!(Tabular::Arrow::ToTabular[
        Tabular::Arrow::ReadArrowIPCByteArray[something],
        "STRING"
    ]);

    assert_eq!(head(&e), "Tabular`Arrow`ToTabular");
    let ExprKind::Normal(outer) = e.kind() else { panic!("expected Normal") };

    let inner = &outer.elements()[0];
    assert_eq!(head(inner), "Tabular`Arrow`ReadArrowIPCByteArray");
    let ExprKind::Normal(inner_n) = inner.kind() else { panic!("expected Normal") };
    assert_eq!(inner_n.elements()[0], Expr::from(42i64));

    assert_eq!(outer.elements()[1], Expr::from("STRING"));
}

#[test]
fn qualified_symbol_as_argument() {
    let e = expr!(System::Head[System::All, 1]);
    let ExprKind::Normal(n) = e.kind() else { panic!("expected Normal") };
    assert_eq!(head(&e), "System`Head");
    assert_eq!(n.elements()[0], Expr::symbol(Symbol::new("System`All")));
    assert_eq!(n.elements()[1], Expr::from(1i64));
}