Blocked by fehler issue 39

Possibly these should be in a separate crate

Do we want to ignore an error if some goods were consumed?

Details should be explained in documentation.

Currently, Consumer and Producer assume their market is finite and thus having an empty or full stock is a possible error. However, there are some implementations which have an infinite or never empty stock and thus it would be nice if their interface indicated this. Ex: have consume return Self::Error instead of ConsumeError<Self::Error>.

Should be replaced by impl<T: From<F>> From<ConsumeFailure<F>> for ConsumeFailure<T>.

Blocked by stabilization of specialization.

create_assembly_line() shall create PartsInput: Producer<Good = u8> and Assembler: Consumer<Good = G>
create_disassembly_line() shall create GoodsInput: Producer<Good = G> and Disassembler: Consumer<Good = u8>

Allow for calling produce() with no good provided. Example use case can be found in sync::Trigger

This generally would require Self::Good: Clone but there are some cases, such as Writer where this should be overridden.

Blocked by stabilization of specialization

Possible new crate name markets?

Blocked by thiserror PR 107

Should probably rename to ConsumeFault and ProduceFault.

If this is done, then we can likely revert the mod order in lib.rs

These are returned when consume() and produce() " fail to perform their functionality, even though there may be no error (such the the stock is empty).

Each function will be gated by a new time feature.

• _until will take a time::OffsetDateTime that indicates when the block will be released. It will block until the action is successful or the current time is greater than the given time.
• _for will take a time::Duration that indicates how long the block will occur. It will calculate the time::OffsetDateTime and call _until

Example use case for Producer can be found in sync::Trigger

Once specialization has been stabilized, deprecate Blame and TryBlame in favor of From and TryFrom with bounds.

Current:

impl<F: Flaws, W: Flaws> Blame<Fault<W> for Fault<F>
where
    W::Insufficiency: From<F::Insufficiency>,
    W::Defect: From<F::Defect>,

Eventual:

impl<F: Flaws, W: Flaws> From<Fault<W> for Fault<F>
where
    F::Insufficiency: From<W::Insufficiency>,
    F::Defect: From<W::Defect>,