Crate seq [] [src]

The module seq provides the lightweight, generic sequence container Seq for unmovable data and is embedded into the program during compile time. Elements of Seq are stacked on top of each other.

Initially a sequence is empty. A longer sequence is constructed attaching a new head to the existing sequence, representing the tail.

Multiple sequences may share the same tail, permitting memory-efficient organisation of hierarchical data.

Put this in your Cargo.toml:

## Cargo.toml file
seq = "0.5"

The "default" usage of this type as a queue is to use Empty or ConsRef to construct a queue, and head and tail to deconstruct a queue into head and remaining tail of a sequence.


Constructing two sequences seq1 as [1,0] and seq2 as [2,1,0], sharing data with seq1

use seq::Seq;

// constructing the sequence 'seq1'
const seq1: Seq<i32> = Seq::ConsRef(1, &Seq::ConsRef(0, &Seq::Empty));

// construction the sequence 'seq2' sharing data with 'seq1'
const seq2: Seq<i32> = Seq::ConsRef(2, &seq1);

Deconstructing a sequence

use seq::Seq;

fn print_head<'a>(seq: &'a Seq<i32>) {
   println!("head {}", seq.head().unwrap());

Extend an existing sequence. Note the lifetime of the return type matches the one of the tail.

use seq::Seq;

fn extend<'a>(head: i32, tail: &'a Seq<i32>) -> Seq<'a, i32> {
   return Seq::ConsRef(head, tail);

Extend an existing sequence with dynamic element residing in heap-memory

use seq::Seq;

fn extend_boxed<'a>(head: i32, tail: &'a Seq<i32>) -> Box<Seq<'a, i32>> {
   return Box::new(Seq::ConsRef(head, tail));

Iterate a sequence

use seq::Seq;

fn sum_up(seq: &Seq<i32>) -> i32 {
   return seq.into_iter().fold(0, |x, y| x + y);



The seqdef! macro defines a stack-allocated sequence variable for the speficied data list, the last data item in the list will be the top most in the sequence.



The sequence iterator representation



A single-ended, growable, unmovable queue of data, linking constant data with dynamic data.



Function returns static reference to empty list