https://github.com/LaurentMazare/rsexp

S-expression parsing and writing in Rust
https://github.com/LaurentMazare/rsexp

Last synced: 3 months ago
JSON representation

S-expression parsing and writing in Rust

• Host: GitHub
• URL: https://github.com/LaurentMazare/rsexp
• Owner: LaurentMazare
• License: apache-2.0
• Created: 2021-10-09T10:21:03.000Z (about 3 years ago)
• Default Branch: main
• Last Pushed: 2023-04-08T17:34:51.000Z (over 1 year ago)
• Last Synced: 2024-07-16T10:24:02.146Z (4 months ago)
• Language: Rust
• Size: 56.6 KB
• Stars: 17
• Watchers: 4
• Forks: 5
• Open Issues: 1
• Metadata Files:
  • Readme: README.md
  • License: LICENSE-APACHE

Awesome Lists containing this project

README

        
# rsexp

S-expression library for Rust.

[![Build Status](https://github.com/LaurentMazare/rsexp/workflows/Continuous%20integration/badge.svg)](https://github.com/LaurentMazare/rsexp/actions)

[![Latest version](https://img.shields.io/crates/v/rsexp.svg)](https://crates.io/crates/rsexp)

[![Documentation](https://docs.rs/rsexp/badge.svg)](https://docs.rs/rsexp)

![License](https://img.shields.io/crates/l/rsexp.svg)

This implemantion aims at being compatible with OCaml's [sexplib](https://github.com/janestreet/sexplib).

The main type for S-expression is as follows:

```rust

pub enum Sexp {

    Atom(Vec),

    List(Vec),

}

```

## Reading and Writing Sexp Files

Reading a sexp file can be done by first reading the whole

file content and then converting the resulting slice into

a `Sexp` object as follows:

```rust

    let contents = std::fs::read(input_filename)?;

    let sexp = rsexp::from_slice(&contents)?;

```

Writing a sexp file can be done by first serializing the data

to a buffer then writing this buffer out. Alternatively, the

`sexp.write(w)?` function can be used to directly output the

data to a `w` object that implements the `Write` trait.

```rust

    let data = sexp.to_bytes();

    std::fs::write(output_filename, data)?;

```

## Conversion to/from Native Types

The `OfSexp` and `SexpOf` traits define some functions to

convert a given type from/to a `Sexp`. These traits are implemented

for most basic types, including maps. Two associated derive macros

can be used to define these traits on structs and enums.

```rust

#[derive(OfSexp, SexpOf)]

struct StructXYZ {

    x: i64,

    y: Option<(i32, i32)>,

    z: String,

}

#[derive(OfSexp, SexpOf)]

enum Abc {

    A(StructXYZ),

    B { x: i64, z: String },

    C,

}

    let sexp = abc.sexp_of();

    let abc: Abc = sexp.of_sexp()?;

```