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 }