PTV/radn-rs
1
1
Fork 0
Code Issues 3 Pull Requests Packages Projects Releases Wiki Activity

MonadFailAnyExt:speculative

Browse Source
This commit is contained in:
AF 2023-05-23 21:21:02 +00:00
parent d9c8cff1db
commit 725eb6636e
2 changed files with 120 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/func.rs
View File

@ -13,6 +13,7 @@ mod controlflow;
pub mod copy_func;
pub mod derivations;
pub mod instances;
mod speculative;
#[cfg(test)]
pub mod test_suite;
#[cfg(test)]
@ -372,6 +373,16 @@ pub trait MonadFailAnyExt: MonadFailAny {
{
<Self::W<E> as Fail<E>>::fail(e)
}
fn speculative<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
wwa: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, A>>,
wwb: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, B>>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
<Self as speculative::SpeculativeFail>::speculative(wwa, wwb)
}
}
impl<Fallible: ?Sized + MonadFailAny> MonadFailAnyExt for Fallible {}

109
src/func/speculative.rs Normal file
View File

@ -0,0 +1,109 @@
use super::*;
type Fwa<'a, A, E0, E1, Fallible> = <<Fallible as MonadFailAny>::T as WeakFunctor>::F<
'a,
Result<<<Fallible as MonadFailAny>::W<E0> as WeakFunctor>::F<'a, A>, E1>,
>;
pub trait SpeculativeFail: MonadFailAny {
fn _speculative_a_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
a: Result<A, E0>,
wb: Result<<Self::W<E0> as WeakFunctor>::F<'a, B>, E1>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
match wb {
Ok(wb) => match a {
Ok(a) => Self::map_err(<Self::W<E0> as Functor>::fmap(|b| (a, b), wb), Ok),
Err(e0) => Self::fail(Ok(e0)),
},
Err(e1) => Self::fail(Err(e1)),
}
}
fn _speculative_a_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
a: Result<A, E0>,
fwb: Fwa<'a, B, E0, E1, Self>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
Self::stuff(<Self::T as Monad>::bind(fwb, |wb| {
Self::unstuff(Self::_speculative_a_wb(a, wb))
}))
}
fn _speculative_fa_wb<'a, A: 'a, B: 'a, E0: 'a>(
fa: <Self::T as WeakFunctor>::F<'a, Result<A, E0>>,
wb: <Self::W<E0> as WeakFunctor>::F<'a, B>,
) -> <Self::W<E0> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
<Self::W<E0> as ApplicativeTuple>::tuple((Self::stuff(fa), wb))
}
fn _speculative_wa_fwb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
wa: <Self::W<E0> as WeakFunctor>::F<'a, A>,
fwb: Fwa<'a, B, E0, E1, Self>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
Self::stuff(<<Self as MonadFailAny>::T as Monad>::join(
<<Self as MonadFailAny>::T as Functor>::fmap(
Self::unstuff,
<Self::T as ApplicativeSelect>::select(
|selected| match selected {
Selected::A(a, fwb) => Self::_speculative_a_fwb(a, fwb),
Selected::B(fa, Ok(wb)) => {
Self::map_err(Self::_speculative_fa_wb(fa, wb), Ok)
}
Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
},
Self::unstuff(wa),
fwb,
),
),
))
}
fn _speculative_fwa_wb<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
fwa: Fwa<'a, A, E0, E1, Self>,
wb: <Self::W<E0> as WeakFunctor>::F<'a, B>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
<Self::W<Result<E0, E1>> as Functor>::fmap(
|(b, a)| (a, b),
Self::_speculative_wa_fwb(wb, fwa),
)
}
fn speculative<'a, A: 'a, B: 'a, E0: 'a, E1: 'a>(
wwa: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, A>>,
wwb: <Self::W<E1> as WeakFunctor>::F<'a, <Self::W<E0> as WeakFunctor>::F<'a, B>>,
) -> <Self::W<Result<E0, E1>> as WeakFunctor>::F<'a, (A, B)>
where
Self: 'a,
{
Self::stuff(<Self::T as Monad>::join(<Self::T as Functor>::fmap(
Self::unstuff,
<Self::T as ApplicativeSelect>::select(
|selected| match selected {
Selected::A(Ok(wa), fwb) => Self::_speculative_wa_fwb(wa, fwb),
Selected::A(Err(e1), _) => Self::fail(Err(e1)),
Selected::B(fwa, Ok(wb)) => Self::_speculative_fwa_wb(fwa, wb),
Selected::B(_, Err(e1)) => Self::fail(Err(e1)),
},
Self::unstuff(wwa),
Self::unstuff(wwb),
),
)))
}
}
impl<Fallible: ?Sized + MonadFailAny> SpeculativeFail for Fallible {}