Struct fluent_builder::StatefulFluentBuilder

pub struct StatefulFluentBuilder<TSeed, TValue, TStack = DefaultStack, TStorage = DefaultStorage> where
    TStorage: Storage<TValue>,  { /* fields omitted */ }

A stateful structure that can contain a value, or stack mutating methods over one supplied later.

Methods

impl<TSeed, TValue, TStack, TStorage> StatefulFluentBuilder<TSeed, TValue, TStack, TStorage> where
    TStorage: Storage<TValue>, 

pub fn from_value(value: TValue) -> Self

Create a new StatefulFluentBuilder from the given value.

pub fn from_seed(seed: TSeed) -> Self

Create a new StatefulFluentBuilder from the given seed.

pub fn value(self, value: TValue) -> Self

Set a value on the builder.

This will override any contained state. That means if the builder currently contains fluent methods then those methods will be discarded.

impl<TSeed, TValue, TStack> StatefulFluentBuilder<TSeed, TValue, TStack, DefaultStorage>

pub fn from_fluent<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Apply<TValue, DefaultStorage, ByValue<TNextStorage>>> where
    TNextStorage: FnOnce(TValue) -> TValue, 

Create a new StatefulFluentBuilder from the given seed and fluent method.

pub fn from_fluent_mut<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Apply<TValue, DefaultStorage, ByRefMut<TNextStorage>>> where
    TNextStorage: FnOnce(&mut TValue), 

Create a new StatefulFluentBuilder from the given seed and fluent method.

This method is the same as from_fluent, but mutates the value instead of replacing it.

impl<TSeed, TValue, TStack> StatefulFluentBuilder<TSeed, TValue, TStack, Shared>

pub fn from_fluent<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Shared> where
    TValue: Send + 'static,
    TSeed: Send + 'static,
    TNextStorage: FnOnce(TValue) -> TValue + Send + 'static, 

Create a new StatefulFluentBuilder from the given seed and fluent method.

pub fn from_fluent_mut<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Shared> where
    TValue: Send + 'static,
    TSeed: Send + 'static,
    TNextStorage: FnOnce(&mut TValue) + Send + 'static, 

Create a new StatefulFluentBuilder from the given seed and fluent method.

This method is the same as from_fluent, but mutates the value instead of replacing it.

impl<TSeed, TValue, TStack> StatefulFluentBuilder<TSeed, TValue, TStack, Boxed>

pub fn from_fluent<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Boxed> where
    TValue: 'static,
    TSeed: 'static,
    TNextStorage: FnOnce(TValue) -> TValue + 'static, 

Create a new StatefulFluentBuilder from the given seed and fluent method.

pub fn from_fluent_mut<TNextStorage>(
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, TStack, Boxed> where
    TValue: 'static,
    TSeed: 'static,
    TNextStorage: FnOnce(&mut TValue) + 'static, 

Create a new StatefulFluentBuilder from the given seed and fluent method.

This method is the same as from_fluent, but mutates the value instead of replacing it.

impl<TSeed, TValue, TStack, TStorage> StatefulFluentBuilder<TSeed, TValue, TStack, TStorage> where
    TStorage: Storage<TValue>, 

pub fn into_value<TDefault>(self, default_value: TDefault) -> TValue where
    TDefault: FnOnce(TSeed) -> TValue + 'static, 

Convert the fluent builder into a value.

This method will consume the builder and return a constructed T. This will have the following behaviour if the builder contains:

• no value or fluent methods, then the default value is constructed.
• a value, then that value is returned.
• no value but fluent methods, then the methods are applied over the default value.
• a value and fluent methods, then the methods are applied over that value.

pub fn try_into_value(self) -> TryIntoValue<TValue, Self>

Attempt to take a value from the builder.

If the builder doesn't contain a concrete value then it is returned in the Builder variant.

Examples

let builder = StatefulFluentBuilder::<i32, String, Stack>::from_value("A value".to_owned())
    .fluent(1, |i, s| format!("{} and more {}", s, i));

match builder.try_into_value() {
    TryIntoValue::Value(value) => {
        // The builder has a value that we can use
        assert_eq!("A value and more 1", value);
    },
    TryIntoValue::Builder(builder) => {
        // The builder doesn't have a value but we can still use it
        let value = builder.into_value(|i| i.to_string());
    }
}

impl<TSeed, TValue, TStorage> StatefulFluentBuilder<TSeed, TValue, Stack, TStorage> where
    TStorage: Storage<TValue>, 

pub fn fluent<TNextStorage>(
    self,
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, Stack, StatefulApply<TSeed, TValue, TStorage::Method, ByValue<TNextStorage>>> where
    TNextStorage: FnOnce(TSeed, TValue) -> TValue, 

Stack a fluent method on the builder.

This will have the following behaviour depending on the current state of the builder if there is:

• no previous value, add the fluent method. This will be applied to a later-supplied default value.
• a previous value, add the fluent method and retain that previous value.
• a previous fluent method, stack this method on top and retain any previous value.

pub fn fluent_mut<TNextStorage>(
    self,
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, Stack, StatefulApply<TSeed, TValue, TStorage::Method, ByRefMut<TNextStorage>>> where
    TNextStorage: FnOnce(TSeed, &mut TValue), 

Stack a fluent method on the builder.

This method behaves the same as fluent, but mutates the value instead of replacing it.

impl<TSeed, TValue, TStorage> StatefulFluentBuilder<TSeed, TValue, Override, TStorage> where
    TStorage: Storage<TValue>, 

pub fn fluent<TNextStorage>(
    self,
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, Override, Apply<TValue, DefaultStorage, ByValue<TNextStorage>>> where
    TNextStorage: FnOnce(TValue) -> TValue + 'static, 

Set the fluent method on the builder.

This will have the following behaviour depending on the current state of the builder if there is:

• no previous value, add the fluent method. This will be applied to a later-supplied default value.
• a previous value, add the fluent method and remove that previous value.
• a previous fluent method, that method will be replaced with the given one.

pub fn fluent_mut<TNextStorage>(
    self,
    seed: TSeed,
    fluent_method: TNextStorage
) -> StatefulFluentBuilder<TSeed, TValue, Override, Apply<TValue, DefaultStorage, ByRefMut<TNextStorage>>> where
    TNextStorage: FnOnce(&mut TValue) + 'static, 

Set the fluent method on the builder.

This method behaves the same as fluent, but mutates the value instead of replacing it.

impl<TSeed, TValue, TStack, TStorage> StatefulFluentBuilder<TSeed, TValue, TStack, TStorage> where
    TSeed: 'static,
    TStorage: Storage<TValue>,
    TStorage::Method: 'static, 

pub fn boxed(self) -> BoxedStatefulFluentBuilder<TSeed, TValue, TStack>

Box a fluent builder so it can be easily captured as a field without generics.

impl<TSeed, TValue, TStack, TStorage> StatefulFluentBuilder<TSeed, TValue, TStack, TStorage> where
    TSeed: 'static,
    TStorage: Storage<TValue>,
    TStorage::Method: Send + 'static, 

pub fn shared(self) -> SharedStatefulFluentBuilder<TSeed, TValue, TStack>

Box a fluent builder so it can be easily shared.