Struct Own

pub struct Own<S, V> {
    pub s: S,
    pub v: V,
}

A return type encapsulating an owned state S and a value V.

It is designed to be used by methods that take ownership of self, and return it alongside the operation-specific result.

By convention methods that return an Own should to be prefixed with own_, and any Result or Option should be part of the state field for the constructors, and part of the value field for most other methods, allowing self to be passed along a chain of operations.

Methods

General methods

Additional const methods are available when both types are Copy.

• Construct: new, empty.
• Deconstruct: sv(const) sv_ref, sv_mut.
• Replace: s_replace(const), v_replace(const), sv_replace(const),
• Wrap: s_wrap_ok(const), s_wrap_some(const), v_wrap_ok(const), v_wrap_some(const),
• Map: s_map, v_map, sv_map.
• Query: s_eq, v_eq, sv_eq.
• Assert: s_assert(or, eq, eq_or), v_assert(or eq, eq_or), sv_assert(or, eq, eq_or).

Methods for when state is a Result

• Map: s_map_ok, s_map_err, s_and, s_and_then.
• Assert: s_assert_ok(or), s_assert_err(or).
• Unwrap: s_unwrap(const), s_unwrap_or(const), s_expect(const).

Methods for when state is an Option

• Map: s_map_some, s_and, s_and_then.
• Assert: s_assert_some(or), s_assert_none(or).
• Unwrap: s_unwrap(const), s_unwrap_or(const), s_expect(const).

Methods for when value is a Result

• Map: v_map_ok, v_map_err, v_and, v_and_then.
• Assert: v_assert_ok(or), v_assert_err(or).
• Unwrap: v_unwrap(const), v_unwrap_or(const), v_expect(const).

Methods for when value is an Option

• Map: v_map_some, v_and, v_and_then.
• Assert: v_assert_some(or), v_assert_none(or).
• Unwrap: v_unwrap(const), v_unwrap_or(const), v_expect(const).

Fields

s: S

The state after the operation.

v: V

The value resulting from the operation.

Implementations

impl<S> Own<S, ()>

pub const fn empty(state: S) -> Own<S, ()>

A constructor with the given state and an empty value.

impl<S, V> Own<S, V>

General methods.

pub const fn new(state: S, value: V) -> Self

A constructor with the given state and value.

pub fn sv(self) -> (S, V)

Returns both state and value as a tuple.

pub const fn sv_ref(&self) -> (&S, &V)

Returns shared references to both state and value.

pub fn sv_mut(&mut self) -> (&mut S, &mut V)

Returns exclusive references to both state and value.

pub fn s_replace(self, new_state: S) -> Self

Replaces the existing state with a new_state.

pub fn v_replace(self, new_value: V) -> Self

Replaces the value with a new_value.

pub fn sv_replace(self, new_state: S, new_value: V) -> Self

Replaces the existing state and value with new_state and new_value, respectively.

pub fn s_wrap_ok<E>(self) -> Own<Result<S, E>, V>

Wraps the state field into Ok.

pub fn s_wrap_some(self) -> Own<Option<S>, V>

Wraps the state field into Some.

pub fn v_wrap_ok<E>(self) -> Own<S, Result<V, E>>

Wraps the value field into Ok.

pub fn v_wrap_some(self) -> Own<S, Option<V>>

Wraps the value field into Some.

pub fn s_map<T, F: FnOnce(S) -> T>(self, f: F) -> Own<T, V>

Applies a mapping function to the state.

pub fn v_map<W, F: FnOnce(V) -> W>(self, f: F) -> Own<S, W>

Applies a mapping function to the value.

pub fn sv_map<F, G, T, W>(self, sf: F, vf: G) -> Own<T, W>

where F: FnOnce(S) -> T, G: FnOnce(V) -> W,

Applies applies a separate mapping function to the state and value.

pub fn s_eq(&self, expected: &S) -> bool

where S: PartialEq,

Returns true if the current state equals the given expected state.

pub fn v_eq(&self, expected: &V) -> bool

where V: PartialEq,

Returns true if the current value equals the given expected value.

pub fn sv_eq(&self, expected_state: &S, expected_value: &V) -> bool

where S: PartialEq, V: PartialEq,

Returns true if the current state and value equals the corresponding expected ones.

pub fn s_assert<F: FnOnce(&S) -> bool>(self, predicate: F) -> Self

Asserts the state matches the predicate, otherwise panics.

Panics

Panics if the predicate returns false.

pub fn s_assert_or<F: FnOnce(&S) -> bool>( self, predicate: F, message: &str, ) -> Self

Asserts the state matches the predicate, otherwise panics with message.

Panics

Panics if the predicate returns false.

pub fn s_assert_eq(self, expected_state: &S) -> Self

where S: PartialEq,

Asserts the state equals expected and returns self, otherwise panics.

Panics

Panics if the state doesn’t equal the expected state.

pub fn s_assert_eq_or(self, expected_state: &S, message: &str) -> Self

where S: PartialEq,

Asserts the state equals expected and returns self, otherwise panics with message.

Panics

Panics if the state doesn’t equal the expected state.

pub fn v_assert<F: FnOnce(&V) -> bool>(self, predicate: F) -> Self

Asserts the value matches the predicate, otherwise panics.

Panics

Panics if the predicate returns false.

pub fn v_assert_or<F: FnOnce(&V) -> bool>( self, predicate: F, message: &str, ) -> Self

Asserts the value matches the predicate, otherwise panics with message.

Panics

Panics if the predicate returns false.

pub fn v_assert_eq(self, expected_value: &V) -> Self

where V: PartialEq,

Asserts the value equals expected and returns self, otherwise panics.

Panics

Panics if the value doesn’t equal the expected value.

pub fn v_assert_eq_or(self, expected_value: &V, message: &str) -> Self

where V: PartialEq,

Asserts the value equals expected and returns self, otherwise panics with message.

Panics

Panics if the value doesn’t equal the expected value.

pub fn sv_assert<F, G>(self, s_predicate: F, v_predicate: G) -> Self

where F: FnOnce(&S) -> bool, G: FnOnce(&V) -> bool,

Asserts both the state and value matches the corresponding predicates, otherwise panics.

Panics

Panics if any predicate returns false.

pub fn sv_assert_or<F, G>( self, s_predicate: F, v_predicate: G, message: &str, ) -> Self

where F: FnOnce(&S) -> bool, G: FnOnce(&V) -> bool,

Asserts both the state and value matches the corresponding predicates, otherwise panics with message.

Panics

Panics if any predicate returns false.

pub fn sv_assert_eq(self, expected_state: &S, expected_value: &V) -> Self

where S: PartialEq, V: PartialEq,

Asserts the state and value equals the corresponding expected ones, and returns self, otherwise panics.

Panics

Panics if either the state or the value are not the expected ones.

pub fn sv_assert_eq_or( self, expected_state: &S, expected_value: &V, message: &str, ) -> Self

where S: PartialEq, V: PartialEq,

Asserts the state and value equals the corresponding expected ones, and returns self, otherwise panics with message

Panics

Panics if either the state or the value are not the expected ones.

impl<S: Copy, V: Copy> Own<S, V>

Additional const

methods for when everything is Copy.

pub const fn sv_const(self) -> (S, V)

Transforms itself into a tuple, in compile-time.

pub const fn s_const_replace(self, s: S) -> Self

Replaces the state self with a new_state, in compile-time.

pub const fn v_const_replace(self, v: V) -> Self

Replaces the value with a new_value, in compile-time.

pub const fn sv_const_replace(self, new_state: S, new_value: V) -> Self

Replaces the state self with a new_state and the value with a new_value, in compile-time.

pub const fn s_const_wrap_ok<E>(self) -> Own<Result<S, E>, V>

Wraps the state field into a Result, in compile-time.

pub const fn s_const_wrap_some(self) -> Own<Option<S>, V>

Wraps the state field into an Option, in compile-time.

pub const fn v_const_wrap_ok<E>(self) -> Own<S, Result<V, E>>

Wraps the value field into a Result, in compile-time.

pub const fn v_const_wrap_some(self) -> Own<S, Option<V>>

Wraps the value field into an Option, in compile-time.

impl<S, E, V> Own<Result<S, E>, V>

Additional methods for when the state is a Result.

pub fn s_map_ok<T, F: FnOnce(S) -> T>(self, op: F) -> Own<Result<T, E>, V>

Maps a Result<S> to a Result<T> by applying the op function to a contained Ok value, leaving an Err value untouched.

pub fn s_map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Own<Result<S, F>, V>

Maps a Result<S, E> to a Result<S, F> by applying the op function to a contained Err value, leaving an Ok value untouched.

pub fn s_and<T>(self, res: Result<T, E>) -> Own<Result<T, E>, V>

Returns res if the state is Ok, otherwise returns the Err value of self.

pub fn s_and_then<T, F: FnOnce(S) -> Result<T, E>>( self, op: F, ) -> Own<Result<T, E>, V>

Calls op if the state is Ok, otherwise returns the Err value of self.

pub const fn s_assert_ok(self) -> Self

Asserts the state is Ok and returns self, otherwise panics.

Panics

Panics if the state is Err.

pub const fn s_assert_ok_or(self, message: &'static str) -> Self

Asserts the state is Ok and returns self, otherwise panics with message.

Panics

Panics if the state is Err.

pub const fn s_assert_err(self) -> Self

Asserts the state is Err and returns self, otherwise panics.

Panics

Panics if the state is Ok.

pub const fn s_assert_err_or(self, message: &'static str) -> Self

Asserts the state is Err and returns self, otherwise panics with message.

Panics

Panics if the state is Ok.

pub fn s_unwrap(self) -> Own<S, V>

Unwraps the contained Ok(state) or panics.

Panics

Panics if the state is Err.

pub fn s_unwrap_or(self, default: S) -> Own<S, V>

Unwraps the contained Ok(state) or provides a default.

Panics

Panics if the state is Err.

pub fn s_expect(self, message: &str) -> Own<S, V>

where E: Debug,

Unwraps the contained Ok(state) or panics with a message.

Panics

Panics if the state is Err.

impl<S: Copy, E: Copy, V: Copy> Own<Result<S, E>, V>

const

methods for when everything is Copy and the state is a Result.

pub const fn s_const_unwrap(self) -> Own<S, V>

Unwraps the contained Ok(state) or panics.

Panics

Panics if the state is Err.

pub const fn s_const_unwrap_or(self, default: S) -> Own<S, V>

Unwraps the contained Ok(state) or provides a default.

pub const fn s_const_expect(self, message: &'static str) -> Own<S, V>

Unwraps the contained Ok(state) or panics with the given message.

Panics

Panics if the state is Err.

impl<S, V> Own<Option<S>, V>

Additional methods for when the value field is an Option.

pub fn s_map_some<T, F: FnOnce(S) -> T>(self, op: F) -> Own<Option<T>, V>

Maps an Option<S> to an Option<T> by applying the op function to a contained state (if Some), or returns None (if None).

pub fn s_and<T>(self, res: Option<T>) -> Own<Option<T>, V>

Returns None if the state is None, otherwise returns optb.

pub fn s_and_then<T, F: FnOnce(S) -> Option<T>>( self, op: F, ) -> Own<Option<T>, V>

Returns None if the state is None, otherwise calls op with the wrapped state and returns the result.

pub const fn s_assert_some(self) -> Self

Asserts the state is Some and returns self, otherwise panics.

Panics

Panics if the state is None.

pub const fn s_assert_some_or(self, message: &'static str) -> Self

Asserts the state is Some and returns self, otherwise panics with message.

Panics

Panics if the state is None.

pub const fn s_assert_none(self) -> Self

Asserts the state is None and returns self, otherwise panics.

Panics

Panics if the state is Some.

pub const fn s_assert_none_or(self, message: &'static str) -> Self

Asserts the state is None and returns self, otherwise panics with message.

Panics

Panics if the state is Some.

pub fn s_unwrap(self) -> Own<S, V>

Unwraps the contained Some(state) or panics.

Panics

Panics if the state is None.

pub fn s_unwrap_or(self, default: S) -> Own<S, V>

Unwraps the contained Some(state) or provides a default.

pub fn s_expect(self, message: &str) -> Own<S, V>

Unwraps the contained Some(state) or panics with the given message.

Panics

Panics if the state is None.

impl<S: Copy, V: Copy> Own<Option<S>, V>

const

methods for when everything is Copy and the value is an Option.

pub const fn s_const_unwrap(self) -> Own<S, V>

Unwraps the contained Some(state) or panics.

Panics

Panics if the state is None.

pub const fn s_const_unwrap_or(self, default: S) -> Own<S, V>

Unwraps the contained Some(state) or provides a default.

pub const fn s_const_expect(self, message: &'static str) -> Own<S, V>

Unwraps the contained Some(state) or panics with the given message.

Panics

Panics if the state is None.

impl<S, V, E> Own<S, Result<V, E>>

Additional methods for when the value field is a Result.

pub fn v_map_ok<W, F: FnOnce(V) -> W>(self, op: F) -> Own<S, Result<W, E>>

Maps a Result<V> to a Result<W> by applying the op function to a contained Ok value, leaving an Err value untouched.

pub fn v_map_err<F, O: FnOnce(E) -> F>(self, op: O) -> Own<S, Result<V, F>>

Maps a Result<V, E> to a Result<V, F> by applying the op function to a contained Err value, leaving an Ok value untouched.

pub fn v_and<W>(self, res: Result<W, E>) -> Own<S, Result<W, E>>

Returns res if the result is Ok, otherwise returns the Err value of self.

pub fn v_and_then<W, F: FnOnce(V) -> Result<W, E>>( self, op: F, ) -> Own<S, Result<W, E>>

Calls op if the result is Ok, otherwise returns the Err value of self.

pub const fn v_assert_ok(self) -> Self

Asserts the value is Ok and returns self, otherwise panics.

Panics

Panics if the value is Err.

pub const fn v_assert_ok_or(self, message: &'static str) -> Self

Asserts the value is Ok and returns self, otherwise panics with message.

Panics

Panics if the value is Err.

pub const fn v_assert_err(self) -> Self

Asserts the value is Err and returns self, otherwise panics.

Panics

Panics if the value is Ok.

pub const fn v_assert_err_or(self, message: &'static str) -> Self

Asserts the value is Err and returns self, otherwise panics with message.

Panics

Panics if the value is Ok.

pub fn v_unwrap(self) -> Own<S, V>

Unwraps the contained Ok(value) or panics.

Panics

Panics if the value is Err.

pub fn v_unwrap_or(self, default: V) -> Own<S, V>

Unwraps the contained Ok(value) or provides a default.

pub fn v_expect(self, message: &str) -> Own<S, V>

where E: Debug,

Unwraps the contained Ok(value) or panics with a message.

Panics

Panics if the value is Err.

impl<S: Copy, V: Copy, E: Copy> Own<S, Result<V, E>>

const

methods for when everything is Copy and the value is a Result.

pub const fn v_const_unwrap(self) -> Own<S, V>

Unwraps the contained Ok(value) or panics.

Panics

Panics if the value is Err.

pub const fn v_const_unwrap_or(self, default: V) -> Own<S, V>

Unwraps the contained Ok(value) or provides a default.

pub const fn v_const_expect_const(self, message: &'static str) -> Own<S, V>

Unwraps the contained Ok(value) or panics with the given message.

Panics

Panics if the value is Err.

impl<S, V> Own<S, Option<V>>

Additional methods for when the value field is an Option.

pub fn v_map_some<W, F: FnOnce(V) -> W>(self, op: F) -> Own<S, Option<W>>

Maps an Option<V> to an Option<W> by applying the op function to a contained value (if Some), or returns None (if None).

pub fn v_and<W>(self, optb: Option<W>) -> Own<S, Option<W>>

Returns None if the value is None, otherwise returns optb.

pub fn v_and_then<W, F: FnOnce(V) -> Option<W>>( self, op: F, ) -> Own<S, Option<W>>

Returns None if the value is None, otherwise calls op with the wrapped value and returns the result.

pub const fn v_assert_some(self) -> Self

Asserts the value is Some and returns self, otherwise panics.

Panics

Panics if the value is None.

pub const fn v_assert_some_or(self, message: &'static str) -> Self

Asserts the value is Some and returns self, otherwise panics with message.

Panics

Panics if the value is None.

pub const fn v_assert_none(self) -> Self

Asserts the value is None and returns self, otherwise panics.

Panics

Panics if the value is Some.

pub const fn v_assert_none_or(self, message: &'static str) -> Self

Asserts the value is None and returns self, otherwise panics with message.

Panics

Panics if the value is Some.

pub fn v_unwrap(self) -> Own<S, V>

Unwraps the contained Some(value) or panics.

Panics

Panics if the value is None.

pub fn v_unwrap_or(self, default: V) -> Own<S, V>

Unwraps the contained Some(value) or provides a default.

pub fn v_expect(self, message: &str) -> Own<S, V>

Unwraps the contained Some(value) or panics with the given message.

Panics

Panics if the value is None.

impl<S: Copy, V: Copy> Own<S, Option<V>>

const

methods for when everything is Copy and the value is an Option.

pub const fn v_const_unwrap(self) -> Own<S, V>

Unwraps the contained Some(value) or panics.

Panics

Panics if the value is None.

pub const fn v_const_unwrap_or(self, default: V) -> Own<S, V>

Unwraps the contained Some(value) or provides a default.

pub const fn v_const_expect(self, message: &'static str) -> Own<S, V>

Unwraps the contained Some(value) or panics with the given message.

Panics

Panics if the value is None.

Trait Implementations

impl<S: Clone, V: Clone> Clone for Own<S, V>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: ConstDefault, V: ConstDefault> ConstDefault for Own<S, V>

const DEFAULT: Self

Returns the compile-time “default value” for a type.

impl<S: Debug, V: Debug> Debug for Own<S, V>

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

Formats the value using the given formatter.

impl<S: Default, V: Default> Default for Own<S, V>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Display, V: Display> Display for Own<S, V>

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

Formats the value using the given formatter.

impl<S: Ord, V: Ord> Ord for Own<S, V>

fn cmp(&self, other: &Self) -> Ordering

State’s ordering takes precedence over value’s ordering.

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<S: PartialEq, V: PartialEq> PartialEq for Own<S, V>

fn eq(&self, other: &Self) -> 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<S: PartialOrd, V: PartialOrd> PartialOrd for Own<S, V>

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

State’s ordering takes precedence over value’s ordering.

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<S: Copy, V: Copy> Copy for Own<S, V>

impl<S: Eq, V: Eq> Eq for Own<S, V>