deep_causality_haft 0.3.1

HKT traits for for the deep_causality crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

/*
 * SPDX-License-Identifier: MIT
 * Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
 */

use crate::{Applicative, Foldable, Functor, HKT, Monad, NoConstraint, Pure, Satisfies};
use alloc::collections::LinkedList;

/// `LinkedListWitness` is a zero-sized type that acts as a Higher-Kinded Type (HKT) witness
/// for the `LinkedList<T>` type constructor. It allows `LinkedList` to be used with generic
/// functional programming traits like `Functor`, `Applicative`, `Foldable`, and `Monad`.
///
/// # Constraint
///
/// `LinkedListWitness` uses `NoConstraint`, meaning it works with any type `T`.
pub struct LinkedListWitness;

impl HKT for LinkedListWitness {
    type Constraint = NoConstraint;

    /// Specifies that `LinkedListWitness` represents the `LinkedList<T>` type constructor.
    type Type<T> = LinkedList<T>;
}

// Implementation of Functor for LinkedListWitness
impl Functor<LinkedListWitness> for LinkedListWitness {
    /// Implements the `fmap` operation for `LinkedList<T>`.
    fn fmap<A, B, Func>(m_a: LinkedList<A>, f: Func) -> LinkedList<B>
    where
        A: Satisfies<NoConstraint>,
        B: Satisfies<NoConstraint>,
        Func: FnMut(A) -> B,
    {
        m_a.into_iter().map(f).collect()
    }
}

// Implementation of Foldable for LinkedListWitness
impl Foldable<LinkedListWitness> for LinkedListWitness {
    /// Folds (reduces) a `LinkedList` into a single value.
    fn fold<A, B, Func>(fa: LinkedList<A>, init: B, f: Func) -> B
    where
        Func: FnMut(B, A) -> B,
    {
        fa.into_iter().fold(init, f)
    }
}

// Implementation of Pure for LinkedListWitness
impl Pure<LinkedListWitness> for LinkedListWitness {
    /// Lifts a pure value into a `LinkedList` containing only that value.
    fn pure<T>(value: T) -> LinkedList<T>
    where
        T: Satisfies<NoConstraint>,
    {
        let mut list = LinkedList::new();
        list.push_back(value);
        list
    }
}

// Implementation of Applicative for LinkedListWitness
impl Applicative<LinkedListWitness> for LinkedListWitness {
    /// Applies a list of functions to a list of values.
    fn apply<A, B, Func>(f_ab: LinkedList<Func>, f_a: LinkedList<A>) -> LinkedList<B>
    where
        A: Satisfies<NoConstraint> + Clone,
        B: Satisfies<NoConstraint>,
        Func: Satisfies<NoConstraint> + FnMut(A) -> B,
    {
        f_ab.into_iter()
            .flat_map(|mut f_val| {
                f_a.iter()
                    .map(move |a_val| f_val(a_val.clone()))
                    .collect::<LinkedList<B>>()
            })
            .collect()
    }
}

// Implementation of Monad for LinkedListWitness
impl Monad<LinkedListWitness> for LinkedListWitness {
    /// Implements the `bind` (or `flat_map`) operation for `LinkedList<T>`.
    fn bind<A, B, Func>(m_a: LinkedList<A>, f: Func) -> LinkedList<B>
    where
        A: Satisfies<NoConstraint>,
        B: Satisfies<NoConstraint>,
        Func: FnMut(A) -> LinkedList<B>,
    {
        m_a.into_iter().flat_map(f).collect()
    }
}