citadel_proto 0.13.0

Networking library for the Citadel Protocol
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Functional Programming Utilities for Citadel Protocol
//!
//! This module provides functional programming utilities and extensions to enhance
//! code readability and maintainability. It implements monadic-style operations
//! and conditional chaining for Rust's native types.
//!
//! # Features
//!
//! - Method chaining with `Then` trait
//! - Conditional branching with `IfEq` and `IfTrue`
//! - Tuple mapping with `PairMap`
//! - Lazy evaluation support
//! - Type-safe conditional operations
//!
//! # Important Notes
//!
//! - All operations are zero-cost abstractions
//! - Implements `FnOnce` for lazy evaluation
//! - Preserves type safety through generics
//! - Supports both eager and lazy evaluation
//!
//! # Related Components
//!
//! - Used throughout the codebase for functional patterns
//! - Integrates with error handling and option types
//! - Supports protocol state management
//! - Enhances packet processing readability

pub trait Then<U, F: Fn(Self) -> U>
where
    Self: Sized,
{
    fn then(self, fx: F) -> U;
}

impl<T: Sized, U, F: Fn(T) -> U> Then<U, F> for T {
    #[inline]
    fn then(self, fx: F) -> U {
        fx(self)
    }
}

pub struct IfEq<J> {
    true_value: Option<J>,
}

impl<J> IfEq<J> {
    pub fn if_false_then(self, lambda: impl FnOnce() -> J) -> J {
        self.true_value.unwrap_or_else(lambda)
    }

    pub fn if_false(self, value: J) -> J {
        self.true_value.unwrap_or(value)
    }
}

pub trait IfEqConditional<J>
where
    Self: PartialEq,
{
    fn if_eq(self, other: Self, value: J) -> IfEq<J>;
    fn if_eq_then(self, other: Self, lambda: impl FnOnce() -> J) -> IfEq<J>;
}

pub trait IfTrueConditional<J> {
    fn if_true(self, if_true: J) -> IfEq<J>;
    fn if_true_then(self, if_true: impl FnOnce() -> J) -> IfEq<J>;
    fn if_false(self, if_false: J) -> IfEq<J>;
    fn if_false_then(self, if_false: impl FnOnce() -> J) -> IfEq<J>;
}

impl<T: PartialEq, J> IfEqConditional<J> for T {
    fn if_eq(self, other: Self, value: J) -> IfEq<J> {
        if self != other {
            IfEq { true_value: None }
        } else {
            IfEq {
                true_value: Some(value),
            }
        }
    }

    fn if_eq_then(self, other: Self, lambda: impl FnOnce() -> J) -> IfEq<J> {
        if self != other {
            IfEq { true_value: None }
        } else {
            IfEq {
                true_value: Some(lambda()),
            }
        }
    }
}

impl<J> IfTrueConditional<J> for bool {
    fn if_true(self, if_true: J) -> IfEq<J> {
        if self {
            IfEq {
                true_value: Some(if_true),
            }
        } else {
            IfEq { true_value: None }
        }
    }

    fn if_true_then(self, if_true: impl FnOnce() -> J) -> IfEq<J> {
        if self {
            IfEq {
                true_value: Some((if_true)()),
            }
        } else {
            IfEq { true_value: None }
        }
    }

    fn if_false(self, if_false: J) -> IfEq<J> {
        if !self {
            IfEq {
                true_value: Some(if_false),
            }
        } else {
            IfEq { true_value: None }
        }
    }

    fn if_false_then(self, if_false: impl FnOnce() -> J) -> IfEq<J> {
        if !self {
            IfEq {
                true_value: Some((if_false)()),
            }
        } else {
            IfEq { true_value: None }
        }
    }
}

pub trait PairMap<A, B> {
    fn map_left<U, F: FnOnce(A) -> U>(self, fx: F) -> (U, B);
    fn map_right<U, F: FnOnce(B) -> U>(self, fx: F) -> (A, U);
}

impl<A, B> PairMap<A, B> for (A, B) {
    fn map_left<U, F: FnOnce(A) -> U>(self, fx: F) -> (U, B) {
        ((fx)(self.0), self.1)
    }
    fn map_right<U, F: FnOnce(B) -> U>(self, fx: F) -> (A, U) {
        (self.0, (fx)(self.1))
    }
}