algar 0.4.1

Algebraic structures, higher-kinded types and other category theory bad ideas
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

use algar::{Applicative, Apply};

use crate::model::turtle::{Angle, Distance, PenColor, PenState, Turtle};

#[derive(PartialEq, Debug)]
pub enum TurtleError {
    InvalidDistance,
    InvalidAngle,
    InvalidPenColor(String),
    InvalidPenState(String),
}

pub fn r#move(turtle: Turtle, distance: &str) -> Result<Turtle, TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_distance(distance.to_string()),
        Turtle::r#move,
    )
}

pub fn r#move2(turtle: Turtle, distance: &str) -> Result<((), Turtle), TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_distance(distance.to_string()),
        Turtle::r#move2,
    )
}

pub fn turn(turtle: Turtle, angle: &str) -> Result<Turtle, TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_angle(angle.to_string()),
        Turtle::turn,
    )
}

pub fn turn2(turtle: Turtle, angle: &str) -> Result<((), Turtle), TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_angle(angle.to_string()),
        Turtle::turn2,
    )
}

pub fn set_pen_color(turtle: Turtle, color: &str) -> Result<Turtle, TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_pen_color(color.to_string()),
        Turtle::set_pen_color,
    )
}

pub fn set_pen_state(turtle: Turtle, state: &str) -> Result<Turtle, TurtleError> {
    Apply::lift_a2(
        Result::<Turtle, TurtleError>::of(turtle),
        validate_pen_state(state.to_string()),
        Turtle::set_pen_state,
    )
}

pub fn validate_distance(d: String) -> Result<Distance, TurtleError> {
    match d.parse::<f32>() {
        Ok(v) => Result::Ok(Distance::new(v)),
        Err(_) => Result::Err(TurtleError::InvalidDistance),
    }
}

pub fn validate_angle(a: String) -> Result<Angle, TurtleError> {
    match a.parse::<f32>() {
        Ok(v) => Result::Ok(Angle::new(v)),
        Err(_) => Result::Err(TurtleError::InvalidAngle),
    }
}

pub fn validate_pen_color(c: String) -> Result<PenColor, TurtleError> {
    match c.to_uppercase().as_str() {
        "RED" => Result::Ok(PenColor::Red),
        "BLACK" => Result::Ok(PenColor::Black),
        c => Result::Err(TurtleError::InvalidPenColor(c.to_string())),
    }
}

pub fn validate_pen_state(s: String) -> Result<PenState, TurtleError> {
    match s.to_uppercase().as_str() {
        "UP" => Result::Ok(PenState::Up),
        "DOWN" => Result::Ok(PenState::Down),
        s => Result::Err(TurtleError::InvalidPenState(s.to_string())),
    }
}

#[cfg(test)]
mod test {
    use crate::model::{turtle::Turtle, turtle_api::TurtleError};

    #[test]
    fn test_api_move_ok() {
        let t = Turtle::default();

        assert!(super::r#move(t, "42").is_ok());
    }

    #[test]
    fn test_api_move_err() {
        let t = Turtle::default();

        assert_eq!(
            super::r#move(t, "NOT A DISTANCE"),
            Result::Err(TurtleError::InvalidDistance)
        );
    }

    #[test]
    fn test_api_turn_ok() {
        let t = Turtle::default();

        assert!(super::turn(t, "42").is_ok());
    }

    #[test]
    fn test_api_turn_err() {
        let t = Turtle::default();

        assert_eq!(
            super::turn(t, "NOT A ANGLE"),
            Result::Err(TurtleError::InvalidAngle)
        );
    }
}