trackler 2.2.1.179 → 2.2.1.180

data/tracks/rust/exercises/palindrome-products/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "palindrome-products"
 version = "1.1.0"
-authors = ["Kirill Meng <kirill.meng@hotmail.de>"]
 
 [dependencies]

data/tracks/rust/exercises/pangram/example.rs

@@ -2,12 +2,12 @@ use std::collections::BTreeSet;
 use std::iter::FromIterator;
 
 pub fn is_pangram(sentence: &str) -> bool {
-    sentence.to_lowercase()
-            .chars()
-            .filter(|c| c.is_alphabetic())
-            .filter(|c| c.is_ascii())
-            .collect::<BTreeSet<char>>() == english_letter_set()
-
+    sentence
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_alphabetic())
+        .filter(|c| c.is_ascii())
+        .collect::<BTreeSet<char>>() == english_letter_set()
 }
 
 fn english_letter_set() -> BTreeSet<char> {

data/tracks/rust/exercises/parallel-letter-frequency/example.rs

@@ -1,7 +1,6 @@
 use std::collections::HashMap;
-use std::thread;
 use std::sync::mpsc::channel;
-
+use std::thread;
 
 /// Compute the frequency of each letter (technically of each unicode codepoint) using the given
 /// number of worker threads.
@@ -9,9 +8,13 @@ pub fn frequency(texts: &[&str], num_workers: usize) -> HashMap<char, usize> {
     assert!(num_workers > 0);
     let part_size_floor = texts.len() / num_workers;
     let rem = texts.len() % num_workers;
-    let part_size = if rem > 0 { part_size_floor + 1 } else { part_size_floor };
+    let part_size = if rem > 0 {
+        part_size_floor + 1
+    } else {
+        part_size_floor
+    };
     let mut parts: Vec<Vec<String>> = Vec::with_capacity(part_size);
-    for _ in 0 .. num_workers {
+    for _ in 0..num_workers {
         parts.push(Vec::with_capacity(part_size));
     }
     let mut i = 0;

data/tracks/rust/exercises/pascals-triangle/example.rs

@@ -4,11 +4,15 @@ pub struct PascalsTriangle {
 
 impl PascalsTriangle {
     pub fn new(row_count: u32) -> Self {
-        PascalsTriangle { row_count: row_count }
+        PascalsTriangle {
+            row_count: row_count,
+        }
     }
 
     pub fn rows(&self) -> Vec<Vec<u32>> {
-        (0..self.row_count).map(|row| PascalsTriangle::row(row)).collect()
+        (0..self.row_count)
+            .map(|row| PascalsTriangle::row(row))
+            .collect()
     }
 
     pub fn row(number: u32) -> Vec<u32> {

data/tracks/rust/exercises/perfect-numbers/example.rs

@@ -2,7 +2,7 @@ pub fn classify(num: u64) -> Option<Classification> {
     if num == 0 {
         return None;
     }
-    let sum: u64 = (1..num).filter(|i| num%i == 0).sum();
+    let sum: u64 = (1..num).filter(|i| num % i == 0).sum();
     if sum == num {
         Some(Classification::Perfect)
     } else if sum < num {
@@ -16,5 +16,5 @@ pub fn classify(num: u64) -> Option<Classification> {
 pub enum Classification {
     Abundant,
     Perfect,
-    Deficient
+    Deficient,
 }

data/tracks/rust/exercises/phone-number/example.rs

@@ -1,21 +1,17 @@
 pub fn number(s: &str) -> Option<String> {
     let digits: String = s.chars().filter(|&c| c.is_digit(10)).collect();
     match digits.len() {
-        10 => {
-            match (digits.chars().nth(0), digits.chars().nth(3)) {
-                (Some('0'), _) => None,
-                (Some('1'), _) => None,
-                (_, Some('0')) => None,
-                (_, Some('1')) => None,
-                _ => Some(digits),
-            }
-        }
-        11 => {
-            match digits.chars().nth(0) {
-                Some('1') => Some(digits[1..].to_string()),
-                _ => None,
-            }
-        }
+        10 => match (digits.chars().nth(0), digits.chars().nth(3)) {
+            (Some('0'), _) => None,
+            (Some('1'), _) => None,
+            (_, Some('0')) => None,
+            (_, Some('1')) => None,
+            _ => Some(digits),
+        },
+        11 => match digits.chars().nth(0) {
+            Some('1') => Some(digits[1..].to_string()),
+            _ => None,
+        },
         _ => None,
     }
 }

data/tracks/rust/exercises/pig-latin/Cargo-example.toml

@@ -1,7 +1,6 @@
 [package]
 name = "pig-latin"
 version = "1.0.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]
 regex = "0.2"

data/tracks/rust/exercises/pig-latin/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "pig-latin"
 version = "1.0.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/pig-latin/example.rs

@@ -1,4 +1,5 @@
-#[macro_use] extern crate lazy_static;
+#[macro_use]
+extern crate lazy_static;
 extern crate regex;
 
 use regex::Regex;
@@ -24,5 +25,8 @@ pub fn translate_word(word: &str) -> String {
 }
 
 pub fn translate(text: &str) -> String {
-    text.split(" ").map(|w| translate_word(w)).collect::<Vec<_>>().join(" ")
+    text.split(" ")
+        .map(|w| translate_word(w))
+        .collect::<Vec<_>>()
+        .join(" ")
 }

data/tracks/rust/exercises/poker/Cargo-example.toml

@@ -1,7 +1,6 @@
 [package]
 name = "poker"
 version = "1.0.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]
 try_opt = "0.1.1"

data/tracks/rust/exercises/poker/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "poker"
 version = "1.1.0"
-authors = ["Peter Goodspeed-Niklaus <peter.r.goodspeedniklaus@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/poker/example.rs

@@ -1,5 +1,5 @@
-use std::fmt;
 use std::cmp::Ordering;
+use std::fmt;
 
 #[macro_use]
 extern crate try_opt;
@@ -181,8 +181,8 @@ impl PokerHand {
     fn is_ace_low_straight(cards: &[Card]) -> bool {
         // special case: ace-low straight
         // still depends on the sorted precondition
-        cards[0].rank.value() == 2 && cards[4].rank == Rank::Ace &&
-            cards
+        cards[0].rank.value() == 2 && cards[4].rank == Rank::Ace
+            && cards
                 .windows(2)
                 .take(3) // (0, 1), (1, 2), (2, 3) --> skips 4, ace
                 .map(|pair| pair[1].rank.value() - pair[0].rank.value())
@@ -201,8 +201,8 @@ impl PokerHand {
             let is_straight = cards
                 .windows(2)
                 .map(|pair| pair[1].rank.value() - pair[0].rank.value())
-                .all(|diff| diff == 1) ||
-                PokerHand::is_ace_low_straight(cards);
+                .all(|diff| diff == 1)
+                || PokerHand::is_ace_low_straight(cards);
 
             if is_flush && is_straight {
                 return Some(PokerHand::StraightFlush);
@@ -269,9 +269,10 @@ impl<'a> Hand<'a> {
     }
 
     fn cmp_high_card(&self, other: &Hand, card: usize) -> Ordering {
-        let mut ordering = self.cards[card].rank.value().cmp(
-            &other.cards[card].rank.value(),
-        );
+        let mut ordering = self.cards[card]
+            .rank
+            .value()
+            .cmp(&other.cards[card].rank.value());
         if card != 0 {
             ordering = ordering.then_with(|| self.cmp_high_card(other, card - 1));
         }

data/tracks/rust/exercises/prime-factors/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "prime_factors"
 version = "1.1.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/prime-factors/example.rs

@@ -1,7 +1,7 @@
 pub fn factors(n: u64) -> Vec<u64> {
     let mut val = n;
     let mut out: Vec<u64> = vec![];
-    let mut possible:u64 = 2;
+    let mut possible: u64 = 2;
     while val > 1 {
         while val % possible == 0 {
             out.push(possible);

data/tracks/rust/exercises/protein-translation/Cargo.toml

@@ -1,4 +1,3 @@
 [package]
 name = "protein-translation"
 version = "0.1.0"
-authors = ["Peter Minten <peter@pminten.nl>"]

data/tracks/rust/exercises/protein-translation/example.rs

@@ -1,12 +1,12 @@
 use std::collections::HashMap;
 
 pub struct CodonInfo<'a> {
-    actual_codons: HashMap<&'a str, &'a str>
+    actual_codons: HashMap<&'a str, &'a str>,
 }
 
 pub fn parse<'a>(pairs: Vec<(&'a str, &'a str)>) -> CodonInfo<'a> {
-    CodonInfo{
-        actual_codons: pairs.into_iter().collect()
+    CodonInfo {
+        actual_codons: pairs.into_iter().collect(),
     }
 }
 
@@ -14,12 +14,13 @@ impl<'a> CodonInfo<'a> {
     pub fn name_for(&self, codon: &str) -> Result<&'a str, &'static str> {
         match self.actual_codons.get(&codon) {
             Some(name) => Ok(name),
-            None => Err("Invalid")
+            None => Err("Invalid"),
         }
     }
 
     pub fn of_rna(&self, strand: &str) -> Result<Vec<&'a str>, &'static str> {
-        strand.chars()
+        strand
+            .chars()
             .collect::<Vec<char>>()
             .chunks(3)
             .map(|chars| self.name_for(&chars.iter().collect::<String>()))

data/tracks/rust/exercises/proverb/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "proverb"
 version = "0.0.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/proverb/example.rs

@@ -1,4 +1,3 @@
-
 pub fn build_proverb(items: Vec<&str>) -> String {
     let mut stanzas = Vec::with_capacity(items.len());
     for index in 0..items.len() {

data/tracks/rust/exercises/pythagorean-triplet/Cargo.toml

@@ -1,6 +1,5 @@
 [package]
 name = "pythagorean_triplet"
 version = "0.0.0"
-authors = ["sacherjj <sacherjj@gmail.com>"]
 
 [dependencies]

data/tracks/rust/exercises/pythagorean-triplet/example.rs

@@ -1,9 +1,9 @@
 pub fn find() -> Option<u32> {
     for a in 1..1000 {
-        for b in (a+1)..(1000-a) {
+        for b in (a + 1)..(1000 - a) {
             let c = 1000 - (a + b);
-            if a*a + b*b == c*c {
-                return Some(a*b*c);
+            if a * a + b * b == c * c {
+                return Some(a * b * c);
             }
         }
     }

data/tracks/rust/exercises/queen-attack/example.rs

@@ -12,9 +12,9 @@ impl ChessPiece for Queen {
     }
 
     fn can_attack<T: ChessPiece>(&self, piece: &T) -> bool {
-        self.position.horizontal_from(&piece.position()) ||
-        self.position.vertical_from(&piece.position()) ||
-        self.position.diagonal_from(&piece.position())
+        self.position.horizontal_from(&piece.position())
+            || self.position.vertical_from(&piece.position())
+            || self.position.diagonal_from(&piece.position())
     }
 }
 

data/tracks/rust/exercises/react/example.rs

@@ -49,7 +49,7 @@ struct ComputeCell<'a, T: Copy> {
     callbacks: HashMap<CallbackID, Box<FnMut(T) -> () + 'a>>,
 }
 
-impl <T: Copy> Cell<T> {
+impl<T: Copy> Cell<T> {
     fn new(initial: T) -> Self {
         Cell {
             value: initial,
@@ -59,7 +59,7 @@ impl <T: Copy> Cell<T> {
     }
 }
 
-impl <'a, T: Copy> ComputeCell<'a, T> {
+impl<'a, T: Copy> ComputeCell<'a, T> {
     fn new<F: Fn(&[T]) -> T + 'a>(initial: T, dependencies: Vec<CellID>, f: F) -> Self {
         ComputeCell {
             cell: Cell::new(initial),
@@ -77,9 +77,9 @@ pub struct Reactor<'a, T: Copy> {
     computes: Vec<ComputeCell<'a, T>>,
 }
 
-impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
+impl<'a, T: Copy + PartialEq> Reactor<'a, T> {
     pub fn new() -> Self {
-        Reactor{
+        Reactor {
             inputs: Vec::new(),
             computes: Vec::new(),
         }
@@ -90,25 +90,42 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
         InputCellID(self.inputs.len() - 1)
     }
 
-    pub fn create_compute<F: Fn(&[T]) -> T + 'a>(&mut self, dependencies: &[CellID], compute_func: F) -> Result<ComputeCellID, CellID> {
+    pub fn create_compute<F: Fn(&[T]) -> T + 'a>(
+        &mut self,
+        dependencies: &[CellID],
+        compute_func: F,
+    ) -> Result<ComputeCellID, CellID> {
         // Check all dependencies' validity before modifying any of them,
         // so that we don't perform an incorrect partial write.
         for &dep in dependencies {
             match dep {
-                CellID::Input(InputCellID(id)) => if id >= self.inputs.len() { return Err(dep) },
-                CellID::Compute(ComputeCellID(id)) => if id >= self.computes.len() { return Err(dep) },
+                CellID::Input(InputCellID(id)) => if id >= self.inputs.len() {
+                    return Err(dep);
+                },
+                CellID::Compute(ComputeCellID(id)) => if id >= self.computes.len() {
+                    return Err(dep);
+                },
             }
         }
         let new_id = ComputeCellID(self.computes.len());
         for &dep in dependencies {
             match dep {
                 CellID::Input(InputCellID(id)) => self.inputs[id].dependents.push(new_id),
-                CellID::Compute(ComputeCellID(id)) => self.computes[id].cell.dependents.push(new_id),
+                CellID::Compute(ComputeCellID(id)) => {
+                    self.computes[id].cell.dependents.push(new_id)
+                }
             }
         }
-        let inputs: Vec<_> = dependencies.iter().map(|&id| self.value(id).unwrap()).collect();
+        let inputs: Vec<_> = dependencies
+            .iter()
+            .map(|&id| self.value(id).unwrap())
+            .collect();
         let initial = compute_func(&inputs);
-        self.computes.push(ComputeCell::new(initial, dependencies.to_vec(), compute_func));
+        self.computes.push(ComputeCell::new(
+            initial,
+            dependencies.to_vec(),
+            compute_func,
+        ));
         Ok(new_id)
     }
 
@@ -121,22 +138,30 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
 
     pub fn set_value(&mut self, id: InputCellID, new_value: T) -> bool {
         let InputCellID(id) = id;
-        self.inputs.get_mut(id).map(|c| {
-            c.value = new_value;
-            c.dependents.clone()
-        }).map(|deps| {
-            for &d in deps.iter() {
-                self.update_dependent(d);
-            }
-            // We can only fire callbacks after all dependents have updated.
-            // So we can't combine this for loop with the one above!
-            for d in deps {
-                self.fire_callbacks(d);
-            }
-        }).is_some()
+        self.inputs
+            .get_mut(id)
+            .map(|c| {
+                c.value = new_value;
+                c.dependents.clone()
+            })
+            .map(|deps| {
+                for &d in deps.iter() {
+                    self.update_dependent(d);
+                }
+                // We can only fire callbacks after all dependents have updated.
+                // So we can't combine this for loop with the one above!
+                for d in deps {
+                    self.fire_callbacks(d);
+                }
+            })
+            .is_some()
     }
 
-    pub fn add_callback<F: FnMut(T) -> () + 'a>(&mut self, id: ComputeCellID, callback: F) -> Option<CallbackID> {
+    pub fn add_callback<F: FnMut(T) -> () + 'a>(
+        &mut self,
+        id: ComputeCellID,
+        callback: F,
+    ) -> Option<CallbackID> {
         let ComputeCellID(id) = id;
         self.computes.get_mut(id).map(|c| {
             c.callbacks_issued += 1;
@@ -146,7 +171,11 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
         })
     }
 
-    pub fn remove_callback(&mut self, cell: ComputeCellID, callback: CallbackID) -> Result<(), RemoveCallbackError> {
+    pub fn remove_callback(
+        &mut self,
+        cell: ComputeCellID,
+        callback: CallbackID,
+    ) -> Result<(), RemoveCallbackError> {
         let ComputeCellID(cell) = cell;
         match self.computes.get_mut(cell) {
             Some(c) => match c.callbacks.remove(&callback) {
@@ -167,7 +196,10 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
                 Some(c) => (&c.dependencies, &c.f, c.cell.dependents.clone()),
                 None => panic!("Cell to update disappeared while querying"),
             };
-            let inputs: Vec<_> = dependencies.iter().map(|&id| self.value(id).unwrap()).collect();
+            let inputs: Vec<_> = dependencies
+                .iter()
+                .map(|&id| self.value(id).unwrap())
+                .collect();
             (f(&inputs), dependents)
         };
 
@@ -179,7 +211,7 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
                     return;
                 }
                 c.cell.value = new_value;
-            },
+            }
             None => panic!("Cell to update disappeared while updating"),
         }
 
@@ -195,14 +227,14 @@ impl <'a, T: Copy + PartialEq> Reactor<'a, T> {
                 if c.cell.value == c.cell.last_value {
                     // Value hasn't changed since last callback fire.
                     // We thus shouldn't fire the callbacks.
-                    return
+                    return;
                 }
                 for cb in c.callbacks.values_mut() {
                     cb(c.cell.value);
                 }
                 c.cell.last_value = c.cell.value;
                 c.cell.dependents.clone()
-            },
+            }
             None => panic!("Callback cell disappeared"),
         };