How to implement flatten(ffa: F<F<A>>) -> F<A> in Rust? - rust

Question

question and my goal
My goal is to let this (playground) compile. Below is the core of the code. This is attempt to implement FlatMap for all F<F<A>>, such as Option<Option<i32>>.
trait HKT1 {
type Unwrapped;
type Wrapped<T>;
}
trait FlatMap: HKT1 + Sized {
fn flat_map<B, F>(self, f: F) -> Self::Wrapped<B>
where
F: FnOnce(Self::Unwrapped) -> Self::Wrapped<B>;
// Below cannot compile
fn flatten<A>(ffa: Self::Wrapped<Self::Wrapped<A>>) -> Self::Wrapped<A>
// How to set generic bound correctly?
where
Self::Wrapped<Self::Wrapped<A>>: FlatMap
{
ffa.flat_map(|x| x)
}
}
error[E0308]: mismatched types
--> src/main.rs:15:26
|
15 | ffa.flat_map(|x| x)
| ^ expected HKT1::Wrapped, found HKT1::Unwrapped
|
= note: expected associated type `<<Self as HKT1>::Wrapped<<Self as HKT1>::Wrapped<A>> as HKT1>::Wrapped<_>`
found associated type `<<Self as HKT1>::Wrapped<<Self as HKT1>::Wrapped<A>> as HKT1>::Unwrapped`
error[E0308]: mismatched types
--> src/main.rs:15:9
|
6 | trait FlatMap: HKT1 + Sized {
| --------------------------- this type parameter
...
11 | fn flatten<A>(ffa: Self::Wrapped<Self::Wrapped<A>>) -> Self::Wrapped<A>
| ---------------- expected `<Self as HKT1>::Wrapped<A>` because of return type
...
15 | ffa.flat_map(|x| x)
| ^^^^^^^^^^^^^^^^^^^ expected type parameter `Self`, found associated type
|
= note: expected associated type `<Self as HKT1>::Wrapped<A>`
found associated type `<<Self as HKT1>::Wrapped<<Self as HKT1>::Wrapped<A>> as HKT1>::Wrapped<_>`
= note: you might be missing a type parameter or trait bound
HKT1 is a way to emulate F<_> and allow all traits that are based on it to access F and _ separately. I learned from this blog.
what I am trying to do
I'm trying to build up a functional programming crate which is kind of translating Scala lib cats to Rust. (Current work here). To implement the higher kinded type, I follow this blog and define the HKT1 trait. It is quite elegant until I want to implement flatten(ffa: F<F<A>>) -> F<A> but cannot figure out how to set the generic bound correctly.
It seems easy to implement if I leave it blank in the trait. For example:
trait FlatMap: HKT1 + Sized {
fn flat_map<B, F>(self, f: F) -> Self::Wrapped<B>
where
F: FnOnce(Self::Unwrapped) -> Self::Wrapped<B>;
fn flatten<A>(ffa: Self::Wrapped<Self::Wrapped<A>>) -> Self::Wrapped<A>;
}
struct MyF<T>(pub T);
impl<A> HKT1 for MyF<A> {
type Unwrapped = A;
type Wrapped<T> = MyF<T>;
}
impl<T> FlatMap for MyF<T> {
fn flat_map<B, F>(self, f: F) -> MyF<B>
where
F: FnOnce(Self::Unwrapped) -> MyF<B>,
{
f(self.0)
}
fn flatten<A>(ffa: MyF<MyF<A>>) -> MyF<A> {
ffa.flat_map(|x| x)
}
}
But I would like to have a default implementation through flat_map. How can I achieve this?

Answer 1

A solution via EqT
I just learned how to achieve this from the implementation of crate functional. (Well, the implementation is a little different from above)
The key idea is to add a trait EqT, whose purpose is to assert two types are equal. (playground)
trait HKT1 {
type Unwrapped;
type Wrapped<T>;
}
trait FlatMap: HKT1 + Sized {
fn flat_map<B, F>(self, f: F) -> Self::Wrapped<B>
where
F: FnOnce(Self::Unwrapped) -> Self::Wrapped<B>;
fn flatten<A>(self) -> Self::Wrapped<A>
where
Self::Unwrapped: EqT<Self::Wrapped<A>>,
{
self.flat_map(|x| x.cast())
}
}
trait EqT<T> {
fn cast(self) -> T;
}
impl<T> EqT<T> for T {
fn cast(self) -> T {
self
}
}
Then we can easily implement and use flatten:
struct MyF<T>(pub T);
impl<A> HKT1 for MyF<A> {
type Unwrapped = A;
type Wrapped<T> = MyF<T>;
}
impl<T> FlatMap for MyF<T> {
fn flat_map<B, F>(self, f: F) -> MyF<B>
where
F: FnOnce(Self::Unwrapped) -> MyF<B>,
{
f(self.0)
}
}
let ffa = MyF(MyF(1));
let fa = ffa.flatten();
println!("{:?}", fa); // Expect MyF(1)