The `Functor`

hierarchy using `higher`

.

# But Why?

This is just a proof of concept implementation of PureScript's functor hierarchy in Rust, and you should probably not use it extensively in your own code, not because it's buggy or unfinished but because it's not likely to produce very nice Rust code. I'm sorry, but this is Rust, it works differently from Haskell.

Nevertheless, if you ever wanted comonads and profunctors in Rust, you've got them.

# What Is The Functor Hierarchy?

Honestly, if you didn't already learn this from Haskell or Scala or PureScript, put down the crate and back away. As mentioned above, you are much better off using Rusty idioms to write your code, and I would recommend learning about these concepts in the context of a language (such as Haskell) where they belong.

If you still want to learn about functors and applicatives and monads, I highly recommend the Category Theory for Programmers series.

# Custom Derives

The `higher-derive`

crate provides a custom derive for
`Functor`

:

```
# use higher_derive::{Lift, Functor};
# use higher::Lift;
# use higher_cat::Functor;
# fn main() {
#[derive(Lift, Functor, PartialEq, Debug)]
enum MyLittleOption<A> {
Definitely(A),
NotReally,
}
// The derive will map any variant field of type `A`:
let i = MyLittleOption::Definitely(123);
let o = i.map(|value: u8| value.to_string());
assert_eq!(MyLittleOption::Definitely("123".to_string()), o);
// And it will leave variants without an `A` in them alone:
let i = MyLittleOption::NotReally;
let o = i.map(|value: u8| value.to_string());
assert_eq!(MyLittleOption::NotReally, o);
# }
```

Please note that this derive only maps types of `A`

, and will not be able to
work on types of eg. `Vec<A>`

. You'll have to write your own `Functor`

implementation for these.