**Monthly Downloads**: 15

**Programming language**: Rust

**License**: Apache License 2.0

## README

## hado

Monadic haskell-like expressions brought to rust via the `hado!`

macro

## What?

A little macro for writing haskell-like do expressions without too much ceremony

## Why?

Rust is a very explicit language when it comes to errors (via Option and Result types) but it can get cumbersome to handle all of them, so this library brings the composable monad pattern from haskell like languages.

Let's show an example: We will try to do simple math and compose possible failures.

First we define our return type, this type will represent the failure or success of the functions.

```
type MathResult = Option<f64>;
```

- Division: if the divisor is 0 we fail

```
fn div(x: f64, y: f64) -> MathResult {
if y == 0.0 {
None
} else {
Some(x / y)
}
}
```

- Square root: if we get a negative number, we fail

```
fn sqrt(x: f64) -> MathResult {
if x < 0.0 {
None
} else {
Some(x.sqrt())
}
}
```

- Logarithm: again if we get a negative number, we fail

```
fn ln(x: f64) -> MathResult {
if x < 0.0 {
None
} else {
Some(x.ln())
}
}
```

Now we want to get two numbers, divide them, get the sqrt of the result and then get the logarithm of the last result

## The naive way

```
fn op(x: f64, y: f64) -> MathResult {
let ratio = div(x, y);
if ratio == None {
return None
};
let ln = ln(ratio.unwrap());
if ln == None {
return None
};
return sqrt(ln.unwrap())
}
```

Even though this code works it's hard to scale, and it isn't idiomatic rust, it
looks more like code you'd see in Java where `None`

is `NULL`

.

## The better way

```
fn op(x: f64, y: f64) -> MathResult {
match div(x, y) {
None => None,
Ok(ratio) => match ln(ratio) {
None => None,
Ok(ln) => sqrt(ln),
},
}
}
```

This example is more rustic but it still looks like too much noise, and still it's very hard to scale

## The FP way

```
fn op(x: f64, y: f64) -> MathResult {
div(x, y).and_then(|ratio|
ln(ratio).and_then(|ln|
sqrt(ln)))
}
```

This way look almost like the special thing that we want to do but those
`and_then`

and closures seem unnecessary

## The hado macro way

```
fn op(x: f64, y: f64) -> MathResult {
hado! {
ratio <- div(x, y);
ln <- ln(ratio);
sqrt(ln)
}
}
```

Here we have a very obvious way of declaring out intent without no sign of error
handling of any kind, we needed to add a trait `Monad`

to Option (which is
already defined by default in this library)

## Error type agnostic

Now some more fancy stuff, you may be thinking ```
but what about the try! macro,
it would certainly make things better, right?
```

and my answer would be yes but
the try macro *only* works on the `Result`

type so there is no way of changing
the type of the error (or use it with our Option based functions).

But now we need to know what was the error that made of computation fail. So we
change the `MathResult`

alias to be a Result of f64 or a custom type `MathError`

```
#[derive(Debug)]
pub enum MathError {
DivisionByZero,
NegativeLogarithm,
NegativeSquareRoot,
}
type MathResult = Result<f64, MathError>;
```

So now we need to change each function because now all the `None`

and `Some`

constructors are a type error

For example div turns into

```
fn div(x: f64, y: f64) -> MathResult {
if y == 0.0 {
Err(MathError::DivisionByZero)
} else {
Ok(x / y)
}
}
```

note that the only changes are:

~~None~~`Err(MathError::DivisionByZero)`

~~Some~~`Ok (x / y)`

and now we check out the op function for each implementation:

*Naive way*: Change all the constructors, the failure checker, luckily rust's type inference saves us from changing too many type declarations.*Better way*: Slightly better, same constructors, but failure checkers are replaced by match statements but still very verbose.*FP way*: a lot better, the only worry we have is that the new error type has some sort of ~and_then~ and everything else should work.*hado way*: Similar to the last, but now there is nothing to change, the computation has no concern over the failure framework.

## How can I use it?

The macro can do some basic stuff based on a trait defined inside the crate
*Monad* which has implementations for Option and Result by default

Let's take some examples from the rust book and rust by example and translate them into hado format.

## Example from Result type reference

Here is the original try based error handling with early returns

```
fn write_info(info: &str) -> io::Result<()> {
let mut file = try!(File::create("my_best_friends.txt"));
println!("file created");
try!(file.write_all(format!("rating: {}\n", info.rating).as_bytes()));
Ok(())
}
```

And here is the hado based

```
fn hado_write_info(string: &str) -> io::Result<()> {
hado!{
mut file <- File::create("my_best_friends.txt");
println!("file created");
file.write_all(format!("string: {}\n", string).as_bytes())
}
}
```

Note that the ign keyword is special, it means that the inner value is discarded
but in the case of failure the whole expressions will short circuit into that
error. Since there is no arrow (`<-`

) the return of the `println`

is completely
discarded so you can have any non failing statements in there (including `let`

and `use`

)

## Multi parameter constructor

let's say we have a Foo struct that has a new method

```
fn new(a: i32, b: f64, s: String) -> Foo {
Foo {
a: i32,
b: f64,
s: String
}
}
```

Create a Option constructor from a normal constructor with minimal hassle

```
fn opt_new(a: Option<i32>, b: Option<f64>, s: Option<String>) -> Option<Foo> {
a <- a;
b <- b;
s <- s;
ret new(a, b, s)
}
```

Note that only by changing the type signature you can change Option to any other monadic type.

You can also do some custom validation without much boilerplate

```
fn opt_new(a: i32, b: f64, s: String) -> Option<Foo> {
a <- validate_a(a);
b <- validate_b(b);
s <- validate_s(s);
ret new(a, b, s)
}
```