Crate ensure

Object implementing Ensure trait are in unknown inital external state and can be brought to a target state.

This can be seen as TryInto trait for objects with side effects with unknown initial external state and desired target state.

By calling ensure() we can be ensured that object is in its target state regardles if it was already in that state or had to be brought to it. If object was already in target state nothing happens. Otherwise ensure() will call meet() on provided EnsureAction type to bring the object into its target state.

If object implements Clone method ensure_verify() can be used to make sure that object fulfills Met condition after EnsureAction type has been preformed.

Closures returning Result<CheckEnsureResult, E> that also return closure in CheckEnsureResult::EnsureAction variant automatically implement Ensure trait. Helper function ensure can be used to call ensure() on such closure.

Example

This program will create file only if it does not exist already.

use std::path::Path;
use std::fs::File;
use ensure::ensure;
use ensure::CheckEnsureResult::*;

let path = Path::new("/tmp/foo.txt");

ensure(|| {
    Ok(if path.exists() {
        Met(())
    } else {
        EnsureAction(|| {
            File::create(&path).map(|file| drop(file))
        })
    })
}).expect("failed to create file");

Existential types

This crate also provides Present<T> and Absent<T> wrapper types to mark ensured external states in type system.

If T implements Ensure<Present<T>> and Ensure<Absetnt<T>> it automatically implements Existential<T> trait that provides methods ensure_present() and ensure_absent().

See tests for example usage.

Structs

Absent	Marks External object as something that does not exist.
Present	Marks External object as something that exists.
VerificationError	Error reported if external object state test failed for object that was ensured to meet that state.

Enums

CheckEnsureResult

Result of verification if object is in target state with check_ensure()

Traits

Ensure	Types of objects that can be brought to target state T.
Existential	Existential types are types that can ensure Present<T> or Absent<T> states for External type T.
External	External objects that state of can be represented in the type system.
ExternalState	State representations of External object in the type system.
Meet	Function that can be used to bring object in its target state.

Functions

ensure

Runs ensure() on object implementing Ensure and return its value. This is useful with closures implementing Ensure.