concepts: Add Post.reject() transition
[learn-rust.git] / concepts / src / lib.rs
1 use std::fs::File;
2 use std::io::prelude::*;
3 use std::collections::HashMap;
4
5 pub fn read_file(path: &str) -> Result<String, std::io::Error> {
6     let mut s = String::new();
7     File::open(path)?
8         .read_to_string(&mut s)?;
9     Ok(s)
10 }
11
12 // needs Copy trait, good for simple types
13 pub fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
14     let mut result = list[0];
15     for &i in list {
16         if i > result {
17             result = i;
18         }
19     }
20     result
21 }
22
23 // expensive for large strings, don't use that
24 pub fn largest_clone<T: PartialOrd + Clone>(list: &[T]) -> T {
25     let mut result = list[0].clone();
26     for i in list {
27         if *i > result {
28             result = i.clone();
29         }
30     }
31     result
32 }
33
34 // good for everything, but more expensive for simple types
35 pub fn largest_ref<T: PartialOrd>(list: &[T]) -> &T {
36     let mut result = &list[0];
37     for i in list {
38         if i > result {
39             result = i;
40         }
41     }
42     result
43 }
44
45 pub fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
46     if x.len() > y.len() {
47         x
48     } else {
49         y
50     }
51 }
52
53 /// Wrap and cache an expensive calculation
54 ///
55 /// This calls a closure just once for every distinct argument. Any subsequent
56 /// call to `.value()` with the same argument uses the cached value.
57 pub struct Cacher<T, A, V>
58 where
59     T: Fn(A) -> V,
60     A: Eq + Copy + std::hash::Hash,
61     V: Copy,
62 {
63     calc: T,
64     values: HashMap<A, V>,
65 }
66
67 impl<T, A, V> Cacher<T, A, V>
68 where
69     T: Fn(A) -> V,
70     A: Eq + Copy + std::hash::Hash,
71     V: Copy,
72 {
73     pub fn new(calc: T) -> Cacher<T, A, V> {
74         Cacher { calc, values: HashMap::new() }
75     }
76
77     pub fn value(&mut self, arg: A) -> V {
78         match self.values.get(&arg) {
79             Some(v) => *v,
80             None => {
81                 let v = (self.calc)(arg);
82                 self.values.insert(arg, v);
83                 v
84             }
85         }
86     }
87 }
88
89 pub struct Counter5 {
90     count: u32
91 }
92
93 impl Counter5 {
94     pub fn new() -> Counter5 {
95         Counter5 { count: 0 }
96     }
97 }
98
99 impl Iterator for Counter5 {
100     type Item = u32;
101
102     fn next(&mut self) -> Option<Self::Item> {
103         if self.count < 5 {
104             self.count += 1;
105             Some(self.count)
106         } else {
107             None
108         }
109     }
110 }
111
112 pub struct Post {
113     state: Box<dyn State>,
114     content: String,
115 }
116
117 impl Post {
118     pub fn new() -> Post {
119         Post {
120             state: Box::new(Draft {}),
121             content: String::new(),
122         }
123     }
124
125     pub fn add_text(&mut self, text: &str) {
126         self.content.push_str(text);
127     }
128
129     pub fn content(&self) -> &str {
130         self.state.content(self)
131     }
132
133     pub fn request_review(&mut self) {
134         self.state = self.state.request_review();
135     }
136
137     pub fn approve(&mut self) {
138         self.state = self.state.approve();
139     }
140
141     pub fn reject(&mut self) {
142         self.state = self.state.reject();
143     }
144 }
145
146 trait State {
147     fn request_review(&self) -> Box<dyn State>;
148     fn approve(&self) -> Box<dyn State>;
149     fn reject(&self) -> Box<dyn State>;
150
151     #[allow(unused_variables)]
152     fn content<'a>(&self, post: &'a Post) -> &'a str {
153         ""
154     }
155 }
156
157 struct Draft {}
158 impl State for Draft {
159     fn request_review(&self) -> Box<dyn State> {
160         Box::new(PendingReview {})
161     }
162
163     fn approve(&self) -> Box<dyn State> {
164         // don't change state
165         Box::new(Self {})
166     }
167
168     fn reject(&self) -> Box<dyn State> {
169         Box::new(Self {})
170     }
171 }
172
173 struct PendingReview {}
174 impl State for PendingReview {
175     fn request_review(&self) -> Box<dyn State> {
176         Box::new(Self {})
177     }
178
179     fn approve(&self) -> Box<dyn State> {
180         Box::new(Published {})
181     }
182
183     fn reject(&self) -> Box<dyn State> {
184         Box::new(Draft {})
185     }
186 }
187
188 struct Published {}
189 impl State for Published {
190     fn request_review(&self) -> Box<dyn State> {
191         Box::new(Self {})
192     }
193
194     fn approve(&self) -> Box<dyn State> {
195         Box::new(Published {})
196     }
197
198     fn reject(&self) -> Box<dyn State> {
199         Box::new(Self {})
200     }
201
202     fn content<'a>(&self, post: &'a Post) -> &'a str {
203         &post.content
204     }
205 }