Useful functional programming toolbelt in Rust. Still largely a WIP.
General idea is to make things easier by providing FP tools in Rust to allow for stuff like this:
```rust use frust::monoid::*;
let v = vec![Some(1), Some(3)]; asserteq!(combineall(&v), Some(4));
// Slightly more magical let t1 = (1, 2.5f32, String::from("hi"), Some(3)); let t2 = (1, 2.5f32, String::from(" world"), None); let t3 = (1, 2.5f32, String::from(", goodbye"), Some(10)); let tuples = vec![t1, t2, t3];
let expected = (3, 7.5f32, String::from("hi world, goodbye"), Some(13)); asserteq!(combineall(&tuples), expected); ```
Things that can be combined.
```rust use frust::semigroup::*;
assert_eq!(Some(1).combine(&Some(2)), Some(3));
asserteq!(All(3).combine(&All(5)), All(1)); // bit-wise && asserteq!(All(true).combine(&All(false)), All(false)); ```
Things that can be combined and have an empty/id value.
```rust use frust::monoid::*;
let t1 = (1, 2.5f32, String::from("hi"), Some(3)); let t2 = (1, 2.5f32, String::from(" world"), None); let t3 = (1, 2.5f32, String::from(", goodbye"), Some(10)); let tuples = vec![t1, t2, t3];
let expected = (3, 7.5f32, String::from("hi world, goodbye"), Some(13)); asserteq!(combineall(&tuples), expected)
let productnums = vec![Product(2), Product(3), Product(4)]; asserteq!(combineall(&productnums), Product(24)) ```
Statically typed heterogeneous lists. Pop as much as you want from one of these; everything remains typed.
```rust
use frust::hlist::*;
let h = hlist![true, "hello", Some(41)]; let (h1, tail1) = h.pop(); asserteq!(h1, true); asserteq!(tail1, hlist!["hello", Some(41)]); ```
Validated is a way of running a bunch of operations that can go wrong (for example,
functions returning Result<T, E>) and, in the case of one or more things going wrong,
having all the errors returned to you all at once. In the case that everything went well, you get
an HList of all your results.
Mapping (and otherwise working with plain) Results is different because it will
stop at the first error, which can be annoying in the very common case (outlined
best by the Cats project).
Here is an example of how it can be used.
```rust
struct Person { age: i32, name: String, }
fn get_name() -> Result
fn get_age() -> Result
// Build up a Validated
let validation = getname().intovalidated() + getage();
// When needed, turn the Validated back into a Result and map as usual
let tryperson = validation.intoresult()
.map(|hlist| {
let (name, (age, _)) = hlist.intotuple2();
Person {
name: name,
age: age,
}
});
asserteq!(person, Result::Ok(Person { name: "James".toowned(), age: 32, }));
/// This next pair of functions always return Recover::Err
fn getnamefaulty() -> Result
fn getagefaulty() -> Result
let validation2 = getnamefaulty().intovalidated() + getagefaulty(); let tryperson2 = validation2.intoresult() .map(|| unimplemented!());
// Notice that we have an accumulated list of errors! asserteq!(tryperson2, Result::Err(vec!["crap name".toowned(), "crap age".toowned()]));
```
It makes sense to start by implementing things that are useful even for idiomatic Rust usage (efficient, and safe). The following might be nice to have:
These are not implemented at all, nor do I know for sure if they
are possible given that Rust has no support for Higher Kinded Types. In addition,
Rustaceans are used to calling iter() on collections to get a lazy view,
manipulating their lists, and then doing a collect() at the end to keep things efficient.
The use of these following structures maybe limited in that context.
FunctorMonadApplyApplicativeShow, Monoid, HList, and Semigroup are at least partially (mostly?) implemented.
Benchmarks would be nice but they're an unstable feature, so perhaps in a different branch.
Yes please !
The following are considered important, in keeping with the spirit of Rust and functional programming:
Scalaz, Cats, Haskell, the usual suspects ;)