https://github.com/seriyps/rust-erl-ext

Erlang external term format codec for Rust language.
https://github.com/seriyps/rust-erl-ext

bert binary-to-term codec erlang rust term-to-binary

Last synced: about 1 month ago
JSON representation

Erlang external term format codec for Rust language.

• Host: GitHub
• URL: https://github.com/seriyps/rust-erl-ext
• Owner: seriyps
• License: apache-2.0
• Created: 2014-07-23T00:16:19.000Z (over 10 years ago)
• Default Branch: master
• Last Pushed: 2016-04-06T11:57:51.000Z (almost 9 years ago)
• Last Synced: 2025-01-02T10:11:43.836Z (about 1 month ago)
• Topics: bert, binary-to-term, codec, erlang, rust, term-to-binary
• Language: Rust
• Size: 66.4 KB
• Stars: 46
• Watchers: 8
• Forks: 10
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • License: LICENSE.txt

Awesome Lists containing this project

README

        
Rust Erl Ext

============

[Erlang external term format](http://erlang.org/doc/apps/erts/erl_ext_dist.html)

parser/serializer for Rust.

[![Build Status](https://travis-ci.org/seriyps/rust-erl-ext.png?branch=master)](https://travis-ci.org/seriyps/rust-erl-ext)

Examples

-------

Decoding

```rust

extern crate erl_ext;

use erl_ext::Decoder;

fn main() {

    let mut decoder = Decoder::new(&mut io::stdin());

    assert!(true == decoder.read_prelude().unwrap());

    println!("{}", decoder.decode_term().unwrap());

}

```

Encoding

```rust

extern crate erl_ext;

use erl_ext::{Eterm, Encoder};

fn main() {

    let term = Eterm::List(vec!(Eterm::SmallInteger(1),

                                Eterm::Integer(1000000),

                                Eterm::Nil));

    // this combination of options make it compatible with erlang:term_to_binary/1

    let utf8_atoms = false;

    let small_atoms = false;

    let fair_new_fun = true;

    let mut encoder = Encoder::new(&mut io::stdout(),

                                   utf8_atoms, small_atoms, fair_new_fun);

    encoder.write_prelude();

    encoder.encode_term(term);

}

```

More examples are in `examples` directory.

Types (all Erlang 17.1 types are supported):

* SmallInteger (u8)     : `0..255`

* Integer (i32)         : `integer()`

* Float (f64)           : `float()`

* Atom (String)         : `atom()`

* Reference             : `reference()` `erlang:make_ref/0`

* Port                  : `port()` eg, socket or raw file or `erlang:open_port/2`

* Pid                   : `pid()`

* Tuple (`Vec`)  : `{ any() }`

* Map (`Vec<(Eterm, Eterm)>`) : `#{any() := any()}`

* Nil                   : `[]`

* String (`Vec`)    : `[0..255]`

* List (`Vec`)   : `[ any() ]`

* Binary (`Vec`)    : `binary()`

* BigNum (`BigInt`)     : `integer() > i32`

* Fun                   : `fun(..) -> ... end.` - deprecated variant

* NewFun                : `fun(..) -> ... end.`

* Export                : `fun my_mod:my_fun/1`

* BitBinary             : `<<128, 128:4>>`

TODO

----

* `serialize::Decoder` and `serialize::Encoder` implementations (not so easy for containers)

* Quick-Check - like tests (feed pseudo-random bytes to decoder, feed random Eterm's to encoder)

Keywords

--------

* Rust

* Erlang

* BERT

* External term format

* term_to_binary, binary_to_term

* parser, serializer