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
88
89

# wolfram-expr

[![Crates.io](https://img.shields.io/crates/v/wolfram-expr.svg)](https://crates.io/crates/wolfram-expr)
![License](https://img.shields.io/crates/l/wolfram-expr.svg)
[![Documentation](https://docs.rs/wolfram-expr/badge.svg)](https://docs.rs/wolfram-expr)

<h4>
  <a href="https://docs.rs/wolfram-expr">API Documentation</a>
  <span> | </span>
  <a href="https://github.com/WolframResearch/wolfram-expr-rs/blob/master/docs/CHANGELOG.md">Changelog</a>
  <span> | </span>
  <a href="https://github.com/WolframResearch/wolfram-expr-rs/blob/master/docs/CONTRIBUTING.md">Contributing</a>
</h4>

Efficient and ergonomic representation of Wolfram expressions in Rust.

## Examples

Construct the expression `{1, 2, 3}`:

```rust
use wolfram_expr::{Expr, Symbol};

let expr = Expr::normal(Symbol::new("System`List"), vec![
    Expr::from(1),
    Expr::from(2),
    Expr::from(3)
]);
```

Pattern match over different expression variants:

```rust
use wolfram_expr::{Expr, ExprKind};

let expr = Expr::from("some arbitrary expression");

match expr.kind() {
    ExprKind::Integer(1) => println!("got 1"),
    ExprKind::Integer(n) => println!("got {}", n),
    ExprKind::Real(_) => println!("got a real number"),
    ExprKind::String(s) => println!("got string: {}", s),
    ExprKind::Symbol(sym) => println!("got symbol named {}", sym.symbol_name()),
    ExprKind::Normal(e) => println!(
        "got expr with head {} and length {}",
        e.head(),
        e.elements().len()
    ),
    // ExprKind is #[non_exhaustive] (variants will be added over time, e.g. for
    // WXF wire types like NumericArray, Association, BigInteger, ...). Catch-all
    // arm keeps your code forward-compatible.
    _ => println!("got some other expression variant"),
}
```

## Related Links

#### Related crates

* [`wolfram-library-link`][wolfram-library-link] — author libraries that can be
  dynamically loaded by the Wolfram Language.
* [`wstp`][wstp] — bindings to the Wolfram Symbolic Transport Protocol, used for passing
  arbitrary Wolfram expressions between programs.
* [`wolfram-app-discovery`][wolfram-app-discovery] — utility for locating local
  installations of Wolfram applications and the Wolfram Language.


[wstp]: https://github.com/WolframResearch/wstp-rs
[wolfram-app-discovery]: https://crates.io/crates/wolfram-app-discovery
[wolfram-library-link]: https://github.com/WolframResearch/wolfram-library-link-rs

## License

 Licensed under either of

  * Apache License, Version 2.0
    ([LICENSE-APACHE](LICENSE-APACHE) or <http://www.apache.org/licenses/LICENSE-2.0>)
  * MIT license
    ([LICENSE-MIT](LICENSE-MIT) or <http://opensource.org/licenses/MIT>)

 at your option.

 ## Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.

See [CONTRIBUTING.md](./docs/CONTRIBUTING.md) for more information.