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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::f32::consts::PI;

#[derive(PartialEq, Debug, Clone)]
pub enum PenState {
    Up,
    Down,
}

#[derive(PartialEq, Debug, Clone)]
pub enum PenColor {
    Black,
    Red,
}

#[derive(PartialEq, Debug, Clone)]
pub struct Position(f32, f32);

impl Position {
    pub fn new(x: f32, y: f32) -> Self {
        Position(x, y)
    }
}

#[derive(PartialEq, Debug, Clone)]
pub struct Angle(f32);

impl Angle {
    pub fn new(x: f32) -> Self {
        Angle(x)
    }
}

#[derive(PartialEq, Debug, Clone)]
pub struct Distance(f32);

impl Distance {
    pub fn new(x: f32) -> Self {
        Distance(x)
    }
}

#[derive(PartialEq, Debug, Clone)]
pub struct Turtle {
    pub position: Position,
    pub angle: Angle,
    pub state: PenState,
    pub color: PenColor,
}

impl Default for Turtle {
    fn default() -> Self {
        Self {
            position: Position(0.0, 0.0),
            angle: Angle(0.0),
            state: PenState::Up,
            color: PenColor::Black,
        }
    }
}

impl Turtle {
    pub fn r#move(self, d: Distance) -> Self {
        Self {
            position: Self::calc_new_position(&d, &self.angle, &self.position),
            ..self
        }
    }

    /// The same as `r#move` but returns a tuple ((), Turtle)
    pub fn r#move2(self, d: Distance) -> ((), Self) {
        (
            (),
            Self {
                position: Self::calc_new_position(&d, &self.angle, &self.position),
                ..self
            },
        )
    }

    pub fn turn(self, angle: Angle) -> Self {
        Self {
            angle: Angle(angle.0),
            ..self
        }
    }

    /// The same as `turn` but returns a tuple ((), Turtle)
    pub fn turn2(self, angle: Angle) -> ((), Self) {
        (
            (),
            Self {
                angle: Angle(angle.0),
                ..self
            },
        )
    }

    pub fn set_pen_state(self, pen_state: PenState) -> Self {
        Self {
            state: pen_state,
            ..self
        }
    }

    pub fn set_pen_color(self, pen_color: PenColor) -> Self {
        Self {
            color: pen_color,
            ..self
        }
    }

    fn calc_new_position(distance: &Distance, angle: &Angle, cur_position: &Position) -> Position {
        let angle_in_rads = angle.0 * PI / 180.0;
        let new_x = cur_position.0 + distance.0 * angle_in_rads.cos();
        let new_y = cur_position.1 + distance.0 * angle_in_rads.sin();

        Position(new_x.ceil(), new_y.ceil())
    }
}

#[cfg(test)]
mod test {

    use super::{Angle, Distance, PenColor, PenState, Position, Turtle};

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

        assert_eq!(t.r#move(Distance(1.0)).position, Position(1.0, 0.0));
    }

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

        assert_eq!(t.turn(Angle(90.0)).angle, Angle(90.0));
    }

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

        assert_eq!(t.set_pen_state(PenState::Down).state, PenState::Down);
    }

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

        assert_eq!(t.set_pen_color(PenColor::Red).color, PenColor::Red);
    }
}