Struct Linear

pub struct Linear<T>(/* private fields */);

A linear type that must be destructured to access the inner value.

Implementations

impl<T> Linear<T>

pub const fn new(inner: T) -> Self

Creates a new linear type.

Examples found in repository

examples/simple_states.rs (line 28)

fn main() {
    // Create a linear type and transition through the states
    let file_content = Linear::new(Filename("README.md"))
        .map(open_file)
        .map_ok(read_text)
        .unwrap_ok();

    // destructure the file content
    let FileContent(text) = file_content.into_inner();
    assert!(text.contains("# Example"));
}

pub fn get_ref(&self) -> &T

Returns a reference to the inner value.

In a pure linear type-system even immutable access to the inner value is not available because this may leak unwanted interior mutability or enable to clone the inner which would be impure (in a linear type system). When one doesn’t do either then the rust type system/lifetimes are strong enough to be pure. This method is only available when one defines the semipure feature. It’s then the decision of the programmer not to use any interior mutability/cloning or bend the rules and do something impure to make this crate more convenient to use.

Example

let linear = Linear::new(123);
assert_eq!(linear.get_ref(), &123);

pub fn into_inner(self) -> T

Destructures the linear type and returns the inner type. This must eventually be called on any linear type, failing to do so will panic.

Example

let linear = Linear::new(123);
let inner = linear.into_inner();
assert_eq!(inner, 123);

Examples found in repository

examples/simple_states.rs (line 34)

fn main() {
    // Create a linear type and transition through the states
    let file_content = Linear::new(Filename("README.md"))
        .map(open_file)
        .map_ok(read_text)
        .unwrap_ok();

    // destructure the file content
    let FileContent(text) = file_content.into_inner();
    assert!(text.contains("# Example"));
}

pub fn map<F: FnOnce(T) -> R, R>(self, f: F) -> Linear<R>

Transforms one linear type to another linear type. The inner value is passed to the closure and the return value is wrapped in a Linear.

Example

let number = Linear::new(123);
let string = number.map(|x| x.to_string());
assert_eq!(string.into_inner(), "123");

Examples found in repository

examples/simple_states.rs (line 29)

fn main() {
    // Create a linear type and transition through the states
    let file_content = Linear::new(Filename("README.md"))
        .map(open_file)
        .map_ok(read_text)
        .unwrap_ok();

    // destructure the file content
    let FileContent(text) = file_content.into_inner();
    assert!(text.contains("# Example"));
}

impl<T: Debug, E: Debug> Linear<Result<T, E>>

Additional methods for Linear<Result<R,E>>, only fundamental map and unwrap methods are supported. Anything beyond that needs to be handled manually.

pub fn map_ok<F: FnOnce(T) -> Result<R, E>, R>( self, f: F, ) -> Linear<Result<R, E>>

Transforms a Linear<Result<T,E>> into Linear<Result<R,E>> by applying a function to the Ok value. Retains a Err value.

Examples found in repository

examples/simple_states.rs (line 30)

fn main() {
    // Create a linear type and transition through the states
    let file_content = Linear::new(Filename("README.md"))
        .map(open_file)
        .map_ok(read_text)
        .unwrap_ok();

    // destructure the file content
    let FileContent(text) = file_content.into_inner();
    assert!(text.contains("# Example"));
}

pub fn map_err<F: FnOnce(E) -> Result<T, R>, R>( self, f: F, ) -> Linear<Result<T, R>>

Transforms a Linear<Result<T,E>> into Linear<Result<T, R>> by applying a function to the Err value. Retains a Ok value.

pub fn unwrap_ok(self) -> Linear<T>

Unwraps a Linear<Result<T,E>> into a Linear<T>.

Panics

When the value is an Err.

Examples found in repository

examples/simple_states.rs (line 31)

fn main() {
    // Create a linear type and transition through the states
    let file_content = Linear::new(Filename("README.md"))
        .map(open_file)
        .map_ok(read_text)
        .unwrap_ok();

    // destructure the file content
    let FileContent(text) = file_content.into_inner();
    assert!(text.contains("# Example"));
}

pub fn unwrap_err(self) -> Linear<E>

Unwraps a Linear<Result<T,E>> into a Linear<E>.

Panics

When the value is an Ok.

impl<T> Linear<Option<T>>

Additional methods for Linear<Option<T>>, only fundamental methods are supported. Anything beyond that needs to be handled manually.

pub fn map_some<F: FnOnce(T) -> Option<R>, R>(self, f: F) -> Linear<Option<R>>

Transforms a Linear<Option<T>> into Linear<Option<R>> by applying a function to the Some value. Retains a None value.

pub fn or_else<F: FnOnce() -> Option<T>>(self, f: F) -> Self

Transforms a Linear<Option<T>> into Linear<Option<T>> by applying a function to the None value. Retains a Some value.

pub fn unwrap_some(self) -> Linear<T>

Unwraps a Linear<Some<T>> into a Linear<T>.

Panics

When the value is None.

Trait Implementations

impl<T: Debug> Debug for Linear<T>

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

Formats the value using the given formatter.

impl<T: Hash> Hash for Linear<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord> Ord for Linear<T>

fn cmp(&self, other: &Linear<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T: PartialEq> PartialEq for Linear<T>

fn eq(&self, other: &Linear<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: PartialOrd> PartialOrd for Linear<T>

fn partial_cmp(&self, other: &Linear<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: Eq> Eq for Linear<T>

impl<T> StructuralPartialEq for Linear<T>