use crate::types::dense_vector::DenseVector;
use deep_causality_haft::{
Applicative, CoMonad, Collectable, DiagonalTraversable, Foldable, Functor, HKT, Monad, Pure,
Semigroupal, Traversable,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct DenseVectorWitness;
impl HKT for DenseVectorWitness {
type Type<T> = DenseVector<T>;
}
impl Functor<DenseVectorWitness> for DenseVectorWitness {
fn fmap<A, B, Func>(m_a: DenseVector<A>, f: Func) -> DenseVector<B>
where
Func: FnMut(A) -> B,
{
DenseVector::from_vec(m_a.into_data().into_iter().map(f).collect())
}
}
impl Foldable<DenseVectorWitness> for DenseVectorWitness {
fn fold<A, B, Func>(fa: DenseVector<A>, init: B, f: Func) -> B
where
Func: FnMut(B, A) -> B,
{
fa.into_data().into_iter().fold(init, f)
}
}
impl Collectable<DenseVectorWitness> for DenseVectorWitness {
fn collect<T, I>(items: I) -> DenseVector<T>
where
I: IntoIterator<Item = T>,
{
DenseVector::from_vec(items.into_iter().collect())
}
}
impl Pure<DenseVectorWitness> for DenseVectorWitness {
fn pure<T>(value: T) -> DenseVector<T> {
DenseVector::from_vec(alloc::vec![value])
}
}
impl Applicative<DenseVectorWitness> for DenseVectorWitness {
fn apply<A, B, Func>(ff: DenseVector<Func>, fa: DenseVector<A>) -> DenseVector<B>
where
A: Clone,
Func: FnMut(A) -> B,
{
let fns = ff.into_data();
let vals = fa.into_data();
let mut out: alloc::vec::Vec<B> = alloc::vec::Vec::with_capacity(fns.len() * vals.len());
for mut g in fns {
for a in vals.iter() {
out.push(g(a.clone()));
}
}
DenseVector::from_vec(out)
}
}
impl Monad<DenseVectorWitness> for DenseVectorWitness {
fn bind<A, B, Func>(fa: DenseVector<A>, mut f: Func) -> DenseVector<B>
where
Func: FnMut(A) -> DenseVector<B>,
{
let mut out = alloc::vec::Vec::new();
for a in fa.into_data() {
out.extend(f(a).into_data());
}
DenseVector::from_vec(out)
}
}
impl Traversable<DenseVectorWitness> for DenseVectorWitness {
fn sequence<A, M>(fa: DenseVector<M::Type<A>>) -> M::Type<DenseVector<A>>
where
M: Applicative<M> + HKT,
A: Clone,
{
let mut acc: M::Type<alloc::vec::Vec<A>> = M::pure(alloc::vec::Vec::new());
for m_a in fa.into_data() {
acc = M::apply(
M::fmap(acc, |v: alloc::vec::Vec<A>| {
move |a: A| {
let mut v = v.clone();
v.push(a);
v
}
}),
m_a,
);
}
M::fmap(acc, DenseVector::from_vec)
}
}
impl CoMonad<DenseVectorWitness> for DenseVectorWitness {
fn extract<A>(fa: &DenseVector<A>) -> A
where
A: Clone,
{
fa.as_slice()
.first()
.cloned()
.expect("a comonad has no counit for an empty container")
}
fn extend<A, B, Func>(fa: &DenseVector<A>, mut f: Func) -> DenseVector<B>
where
A: Clone,
Func: FnMut(&DenseVector<A>) -> B,
{
let n = fa.as_slice().len();
let mut out = alloc::vec::Vec::with_capacity(n);
for i in 0..n {
let view = shifted_view(fa, i);
out.push(f(&view));
}
DenseVector::from_vec(out)
}
}
fn shifted_view<A: Clone>(fa: &DenseVector<A>, index: usize) -> DenseVector<A> {
let s = fa.as_slice();
let n = s.len();
let mut out = alloc::vec::Vec::with_capacity(n);
for i in 0..n {
out.push(s[(i + index) % n].clone());
}
DenseVector::from_vec(out)
}
impl DiagonalTraversable<DenseVectorWitness> for DenseVectorWitness {
fn sequence_zip<A, M>(
fa: DenseVector<M::Type<A>>,
seed: M::Type<DenseVector<A>>,
) -> M::Type<DenseVector<A>>
where
M: Semigroupal<M> + HKT,
{
let mut acc = seed;
for cell in fa.into_data() {
acc = M::zip_with(acc, cell, |slot, a| {
let mut values = slot.into_data();
values.push(a);
DenseVector::from_vec(values)
});
}
acc
}
}