Merge pull request #42 from zdyxry/master
[rust-101.git] / solutions / src / vec.rs
1 pub mod part01 {
2     use std;
3
4     /// A number, or nothing
5     pub enum NumberOrNothing {
6         Number(i32),
7         Nothing
8     }
9     use self::NumberOrNothing::{Number,Nothing};
10
11     /// Compute the minimum element of the vector
12     pub fn vec_min(v: Vec<i32>) -> NumberOrNothing {
13         let mut min = Nothing;
14         for e in v {
15             min = Number(match min {
16                 Nothing => e,
17                 Number(n) => std::cmp::min(n, e)
18             });
19         }
20         min
21     }
22
23     /// Compute the sum of elements in the vector
24     pub fn vec_sum(v: Vec<i32>) -> i32 {
25         let mut sum = 0;
26         for e in v {
27             sum += e;
28         }
29         sum
30     }
31
32     /// Print all elements in the vector
33     pub fn vec_print(v: Vec<i32>) {
34         for e in v {
35             println!("{}", e)
36         }
37     }
38 }
39
40 pub mod part02 {
41     // A polymorphic (generic) "some value, or no value"
42     pub enum SomethingOrNothing<T>  {
43         Something(T),
44         Nothing,
45     }
46     pub use self::SomethingOrNothing::*;
47     type NumberOrNothing = SomethingOrNothing<i32>;
48
49     /// This trait is used to compute the minimum of two elements of the given type
50     pub trait Minimum : Copy {
51         fn min(self, b: Self) -> Self;
52     }
53
54     /// Return the minimum element of the vector
55     pub fn vec_min<T: Minimum>(v: Vec<T>) -> SomethingOrNothing<T> {
56         let mut min = Nothing;
57         for e in v {
58             min = Something(match min {
59                 Nothing => e,
60                 Something(n) => e.min(n)
61             });
62         }
63         min
64     }
65
66     /// We can compute the minimum of two integers
67     impl Minimum for i32 {
68         fn min(self, b: Self) -> Self {
69             if self < b { self } else { b }
70         }
71     }
72
73     /// Sample program to call vec_min
74     impl NumberOrNothing {
75         pub fn print(self) {
76             match self {
77                 Nothing => println!("The number is: <nothing>"),
78                 Something(n) => println!("The number is: {}", n),
79             };
80         }
81     }
82     fn read_vec() -> Vec<i32> {
83         vec![18,5,7,3,9,27]
84     }
85     pub fn main_i32() {
86         let vec = read_vec();
87         let min = vec_min(vec);
88         min.print();
89     }
90
91     // Now, all the same for calling it on f32
92     impl Minimum for f32 {
93         fn min(self, b: Self) -> Self {
94             if self < b { self } else { b }
95         }
96     }
97
98     impl SomethingOrNothing<f32> {
99         pub fn print_f32(self) {
100             match self {
101                 Nothing => println!("The number is: <nothing>"),
102                 Something(n) => println!("The number is: {}", n),
103             };
104         }
105     }
106
107     fn read_vec_f32() -> Vec<f32> {
108         vec![18.01,5.2,7.1,3.,9.2,27.123]
109     }
110     pub fn main_f32() {
111         let vec = read_vec_f32();
112         let min = vec_min(vec);
113         min.print_f32();
114     }
115
116     /// Add a `Display` implementation to `SomethingOrNothing`
117     use std::fmt;
118     impl<T: fmt::Display> fmt::Display for SomethingOrNothing<T> {
119         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
120             match *self {
121                 Something(ref t) => t.fmt(f),
122                 Nothing          => "Nothing".fmt(f),
123             }
124         }
125     }
126 }
127
128 pub mod part03 {
129     use std::io::prelude::*;
130     use std::io;
131
132     fn read_vec() -> Vec<i32> {
133         let mut vec: Vec<i32> = Vec::<i32>::new();
134         let stdin = io::stdin();
135         println!("Enter a list of numbers, one per line. End with Ctrl-D (Linux) or Ctrl-Z (Windows).");
136         for line in stdin.lock().lines() {
137             let line = line.unwrap();
138             match line.trim().parse::<i32>() {
139                 Ok(num) => {
140                     vec.push(num)
141                 },
142                 // We don't care about the particular error, so we ignore it with a `_`.
143                 Err(_) => {
144                     println!("What did I say about numbers?")
145                 },
146             }
147         }
148
149         vec
150     }
151
152     use super::part02::{SomethingOrNothing,Something,Nothing,vec_min};
153
154     pub fn main() {
155         let vec = read_vec();
156         let min = vec_min(vec);
157         min.print2();
158     }
159
160     pub trait Print {
161         fn print(self);
162     }
163     impl Print for i32 {
164         fn print(self) {
165             print!("{}", self);
166         }
167     }
168
169     impl<T: Print> SomethingOrNothing<T> {
170         fn print2(self) {
171             match self {
172                 Nothing => println!("The number is: <nothing>"),
173                 Something(n) => {
174                     print!("The number is: ");
175                     n.print();
176                     println!();
177                 }
178             }
179         }
180     }
181
182     impl Print for f32 {
183         fn print(self) {
184             print!("{}", self);
185         }
186     }
187 }