Struct NonEmptyVec 

pub struct NonEmptyVec<T> {
    pub head: T,
    pub tail: Vec<T>,
}

A non-empty vector: guaranteed to have at least one element.

Fields

head: T

tail: Vec<T>

Implementations

impl<T> NonEmptyVec<T>

pub fn new(head: T, tail: Vec<T>) -> NonEmptyVec<T>

Examples found in repository

examples/cellular_automaton.rs (line 104)

fn main() {
    println!("=== Cellular Automaton Example ===\n");
    println!("Using Extend (Comonad) to evolve a 1D cellular automaton.\n");

    // Initial state: single cell in the middle of a 21-cell grid
    let width = 21;
    let mid = width / 2;
    let mut cells: Vec<u8> = vec![0; width];
    cells[mid] = 1;
    let initial = NonEmptyVec::new(cells[0], cells[1..].to_vec());

    // Rule 90 (XOR of neighbors)
    println!("--- Rule 90 (XOR of neighbors) ---");
    let history = evolve(initial.clone(), rule_90, 10);
    for (i, grid) in history.iter().enumerate() {
        println!("  {:>2}: {}", i, display_grid(grid));
    }

    // Demonstrate Comonad::extract
    println!("\n--- Comonad::extract (read focused cell) ---");
    println!(
        "  Head of initial grid: {}",
        <NonEmptyVecF as Comonad>::extract(&initial)
    );

    // Majority rule
    println!("\n--- Majority rule ---");
    // Start with a more interesting pattern
    let pattern = NonEmptyVec::new(1, vec![0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0]);
    println!("  Initial: {}", display_grid(&pattern));
    let history = evolve(pattern, rule_majority, 8);
    for (i, grid) in history.iter().enumerate() {
        println!("  {:>2}: {}", i, display_grid(grid));
    }

    // Demonstrate Extend::duplicate
    println!("\n--- Extend::duplicate (all focused views) ---");
    let small = NonEmptyVec::new(1, vec![2, 3]);
    let duplicated: NonEmptyVec<NonEmptyVec<u8>> = NonEmptyVecF::duplicate(small);
    println!("  Original: [1, 2, 3]");
    println!("  Duplicated (each row is a focused view):");
    for (i, view) in duplicated.iter().enumerate() {
        let cells: Vec<String> = view.iter().map(|c| c.to_string()).collect();
        println!("    focus {}: [{}]", i, cells.join(", "));
    }
}

pub fn singleton(value: T) -> NonEmptyVec<T>

pub fn len(&self) -> usize

Examples found in repository

examples/cellular_automaton.rs (line 19)

fn rule_90(grid: &NonEmptyVec<u8>) -> u8 {
    let tails = grid.tails();
    let current = <NonEmptyVecF as Comonad>::extract(grid);
    let len = grid.len();

    // Get left neighbor (wrapping)
    let left = if len > 1 {
        // The last tail gives us the rightmost element as neighbor context
        *tails.tail.last().map(|t| &t.head).unwrap_or(&grid.head)
    } else {
        current
    };

    // Get right neighbor
    let right = if grid.tail.is_empty() {
        grid.head // wrap around
    } else {
        grid.tail[0]
    };

    // XOR of neighbors
    left ^ right
}

/// Simpler rule: majority vote of (left, current, right).
/// Cell is alive if 2+ of the three are alive.
fn rule_majority(grid: &NonEmptyVec<u8>) -> u8 {
    let current = <NonEmptyVecF as Comonad>::extract(grid);
    let len = grid.len();

    let left = if len > 1 {
        let tails = grid.tails();
        *tails.tail.last().map(|t| &t.head).unwrap_or(&grid.head)
    } else {
        current
    };

    let right = if grid.tail.is_empty() {
        grid.head
    } else {
        grid.tail[0]
    };

    let sum = left as u16 + current as u16 + right as u16;
    if sum >= 2 { 1 } else { 0 }
}

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = &T>

Examples found in repository

examples/cellular_automaton.rs (line 89)

fn display_grid(grid: &NonEmptyVec<u8>) -> String {
    let mut s = String::new();
    for cell in grid.iter() {
        s.push(if *cell == 1 { '#' } else { '.' });
    }
    s
}

fn main() {
    println!("=== Cellular Automaton Example ===\n");
    println!("Using Extend (Comonad) to evolve a 1D cellular automaton.\n");

    // Initial state: single cell in the middle of a 21-cell grid
    let width = 21;
    let mid = width / 2;
    let mut cells: Vec<u8> = vec![0; width];
    cells[mid] = 1;
    let initial = NonEmptyVec::new(cells[0], cells[1..].to_vec());

    // Rule 90 (XOR of neighbors)
    println!("--- Rule 90 (XOR of neighbors) ---");
    let history = evolve(initial.clone(), rule_90, 10);
    for (i, grid) in history.iter().enumerate() {
        println!("  {:>2}: {}", i, display_grid(grid));
    }

    // Demonstrate Comonad::extract
    println!("\n--- Comonad::extract (read focused cell) ---");
    println!(
        "  Head of initial grid: {}",
        <NonEmptyVecF as Comonad>::extract(&initial)
    );

    // Majority rule
    println!("\n--- Majority rule ---");
    // Start with a more interesting pattern
    let pattern = NonEmptyVec::new(1, vec![0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0]);
    println!("  Initial: {}", display_grid(&pattern));
    let history = evolve(pattern, rule_majority, 8);
    for (i, grid) in history.iter().enumerate() {
        println!("  {:>2}: {}", i, display_grid(grid));
    }

    // Demonstrate Extend::duplicate
    println!("\n--- Extend::duplicate (all focused views) ---");
    let small = NonEmptyVec::new(1, vec![2, 3]);
    let duplicated: NonEmptyVec<NonEmptyVec<u8>> = NonEmptyVecF::duplicate(small);
    println!("  Original: [1, 2, 3]");
    println!("  Duplicated (each row is a focused view):");
    for (i, view) in duplicated.iter().enumerate() {
        let cells: Vec<String> = view.iter().map(|c| c.to_string()).collect();
        println!("    focus {}: [{}]", i, cells.join(", "));
    }
}

pub fn tails(&self) -> NonEmptyVec<NonEmptyVec<T>>

where T: Clone,

Collect all suffixes as a NonEmptyVec of NonEmptyVecs.

Examples found in repository

examples/cellular_automaton.rs (line 17)

fn rule_90(grid: &NonEmptyVec<u8>) -> u8 {
    let tails = grid.tails();
    let current = <NonEmptyVecF as Comonad>::extract(grid);
    let len = grid.len();

    // Get left neighbor (wrapping)
    let left = if len > 1 {
        // The last tail gives us the rightmost element as neighbor context
        *tails.tail.last().map(|t| &t.head).unwrap_or(&grid.head)
    } else {
        current
    };

    // Get right neighbor
    let right = if grid.tail.is_empty() {
        grid.head // wrap around
    } else {
        grid.tail[0]
    };

    // XOR of neighbors
    left ^ right
}

/// Simpler rule: majority vote of (left, current, right).
/// Cell is alive if 2+ of the three are alive.
fn rule_majority(grid: &NonEmptyVec<u8>) -> u8 {
    let current = <NonEmptyVecF as Comonad>::extract(grid);
    let len = grid.len();

    let left = if len > 1 {
        let tails = grid.tails();
        *tails.tail.last().map(|t| &t.head).unwrap_or(&grid.head)
    } else {
        current
    };

    let right = if grid.tail.is_empty() {
        grid.head
    } else {
        grid.tail[0]
    };

    let sum = left as u16 + current as u16 + right as u16;
    if sum >= 2 { 1 } else { 0 }
}

Trait Implementations

impl<T> Clone for NonEmptyVec<T>

where T: Clone,

fn clone(&self) -> NonEmptyVec<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Debug for NonEmptyVec<T>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T> Eq for NonEmptyVec<T>

where T: Eq,

impl<T> PartialEq for NonEmptyVec<T>

where T: PartialEq,

fn eq(&self, other: &NonEmptyVec<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Semigroup for NonEmptyVec<T>

Available on crate features alloc or std only.

fn combine(self, other: NonEmptyVec<T>) -> NonEmptyVec<T>

impl<T> StructuralPartialEq for NonEmptyVec<T>

where T: PartialEq,