Trait List 

pub trait List {
    type Empty: EmptyList;
    type Head: 'static;
    type Tail: List;
    type Push<U: 'static>: List;
    type Append<U: List>: List;
    type ReverseOnto<U: List>: List;

    const LENGTH: usize = _;

    // Required methods
    fn empty() -> Self::Empty;
    fn head(&self) -> &Self::Head;
    fn tail(&self) -> &Self::Tail;
    fn push<U>(self, item: U) -> Self::Push<U>
       where U: 'static;
    fn append<U>(self, other: U) -> Self::Append<U>
       where U: List;
    fn reverse_onto<U>(self, other: U) -> Self::ReverseOnto<U>
       where U: List;

    // Provided methods
    fn is_empty(&self) -> bool { ... }
    fn len(&self) -> usize { ... }
    fn reverse(self) -> Self::ReverseOnto<Self::Empty>
       where Self: Sized { ... }
}

A trait representing a homogeneous list (cons cell) with a head and tail.

The List trait provides a type-safe way to work with lists where each node contains a value (head) and the remainder of the list (tail). This trait is implemented for both empty lists and non-empty lists.

Provided Associated Constants

const LENGTH: usize = _

The length of the list, computed at compile time.

Required Associated Types

type Empty: EmptyList

The type returned by List::empty().

type Head: 'static

The type of head.

type Tail: List

The type of the rest of the list.

type Push<U: 'static>: List

The type of the list after pushing a new value.

type Append<U: List>: List

The style of List appended to Self

type ReverseOnto<U: List>: List

The resulting list when reversing Self onto U.

Required Methods

fn empty() -> Self::Empty

Returns a new empty list that can be used to create a list with the same characteristics.

fn head(&self) -> &Self::Head

Returns a reference to the head.

fn tail(&self) -> &Self::Tail

Returns a reference to the rest of the list.

fn push<U>(self, item: U) -> Self::Push<U>

where U: 'static,

Pushes a new value onto the front of the list, returning a new list.

fn append<U>(self, other: U) -> Self::Append<U>

where U: List,

Append U as the tail of Self.

Example

use cel_runtime::*;

assert_eq!(
    (1, (2, (3, ()))).append((4, (5, (6, ())))),
    (1, (2, (3, (4, (5, (6, ()))))))
);

fn reverse_onto<U>(self, other: U) -> Self::ReverseOnto<U>

where U: List,

Reverse Self and append the result to other.

Provided Methods

fn is_empty(&self) -> bool

Returns true if the list is empty.

fn len(&self) -> usize

Returns the length of the list.

fn reverse(self) -> Self::ReverseOnto<Self::Empty>

where Self: Sized,

Reverse this list, returning a new list with elements in opposite order.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<H, T> List for (H, T)

where H: 'static, T: List,

type Empty = ()

type Head = H

type Tail = T

type Push<U: 'static> = (U, (H, T))

type Append<U: List> = <<T as List>::Append<U> as List>::Push<H>

type ReverseOnto<U: List> = <T as List>::ReverseOnto<<U as List>::Push<H>>

fn empty() -> <(H, T) as List>::Empty

fn head(&self) -> &<(H, T) as List>::Head

fn tail(&self) -> &<(H, T) as List>::Tail

fn push<U>(self, item: U) -> <(H, T) as List>::Push<U>

where U: 'static,

fn append<U>(self, other: U) -> <(H, T) as List>::Append<U>

where U: List,

fn reverse_onto<U>(self, other: U) -> <(H, T) as List>::ReverseOnto<U>

where U: List,

Implementors

impl<H, T> List for CStackList<H, T>

where H: 'static, T: List + CStackListHeadLimit,

type Empty = CNil<()>

type Head = H

type Tail = T

type Push<U: 'static> = CStackList<U, CStackList<H, T>>

type Append<U: List> = <<T as List>::Append<U> as List>::Push<H>

type ReverseOnto<U: List> = <T as List>::ReverseOnto<<U as List>::Push<H>>

impl<T> List for T

where T: EmptyList,

A blanket implementation for EmptyList.

const LENGTH: usize = 0

type Empty = <T as EmptyList>::RootEmpty

type Head = Undefined

type Tail = T

type Push<U: 'static> = <T as EmptyList>::PushFirst<U>

type Append<U: List> = U

type ReverseOnto<U: List> = U