lib.rs

#[macro_use]
extern crate munch;

use munch::{P, Parser};
use munch::byte::*;

#[derive(Debug, PartialEq)]
pub enum Term<'a> {
    SmallInteger(u8),
    Integer(i32),
    List(Vec<Term<'a>>),
    ImproperList(Vec<Term<'a>>),
    Binary(&'a [u8]),
}

pub type Result<T> = munch::Result<T, munch::byte::Error<'static>>;

pub fn parse(bytes: &[u8]) -> Result<Term> {
    (P(131) >> term).parse(bytes, 0)
}

pub fn term(bytes: &[u8], from: usize) -> Result<Term> {
    use self::Term::*;
    muncher! (
        tag <- Any,
        t <- @match (tag) {
            97 => Any.map(SmallInteger),
            98 => BigEndian::i32.map(Integer),
            106 => |_, from| Ok((from, List(Vec::new()))),
            107 => BigEndian::u16.bind(|u16| Any.map(SmallInteger).repeat(u16 as usize).map(List)),
            108 => muncher! {
                len <- BigEndian::u32,
                elements <- term.repeat(len as usize),
                tail <- term,
                ({
                    Ok(if tail == List(Vec::new()) {
                        List(elements)
                    } else {
                        let mut elements = elements;
                        elements.push(tail);
                        ImproperList(elements)
                    })
                })
            },
            109 => BigEndian::u32.bind(|u32| Take(u32 as usize).map(Binary)),
            tag => |_, _| panic!("unimplemented: {:?}", tag),
        },
        (Ok(t))
    )
        .parse(bytes, from)
}