Photo by Philipp Medicus (CC BY-NC 2.0)

Cargo is a tool that allows Rust packages to declare their various dependencies and ensure that you’ll always get a repeatable build.

This week i found something interesting about cargo.

First there is a well organized cargo book. Short and clear text. Cargo is easy to understand if you have ruby bundler or npm background.

Second: there is a list of third party cargo sub commands. Extensions I liked very much:

• cargo fmt - to format all the code with rustfmt (a tool for formatting Rust code according to style guidelines).
• cargo count - to produce statistics for the project (see example below)
• cargo-deb, cargo-rpm, cargo-pkgbuild - for native linux packaging
• cargo-tree - list dependency tree just like `npm ls`
• cargo-audit - Audit Cargo.lock for crates with security vulnerabilities

$ cargo install cargo-count
... skip ...
$ cargo count --all --language rs
Gathering information...
         Language  Files  Lines  Blanks  Comments  Code
         --------  -----  -----  ------  --------  ----
         Rust      7      1324   197     423       704
         --------  -----  -----  ------  --------  ----
Totals:            7      1324   197     423       704

$ cargo install cargo-tree
... skip ...
$ cargo tree

aoc2018 v0.1.0 (/Users/antono/Code/rust/aoc2018)                                                                                                       
├── chrono v0.4.6
│   ├── num-integer v0.1.39
│   │   └── num-traits v0.2.6
│   ├── num-traits v0.2.6 (*)
│   └── time v0.1.41
│       └── libc v0.2.45
│       [dev-dependencies]
│       └── winapi v0.3.6
├── indoc v0.3.1
│   ├── indoc-impl v0.3.1
│   │   ├── proc-macro-hack v0.5.4
│   │   │   ├── proc-macro2 v0.4.24
│   │   │   │   └── unicode-xid v0.1.0
│   │   │   ├── quote v0.6.10
│   │   │   │   └── proc-macro2 v0.4.24 (*)
│   │   │   └── syn v0.15.23
│   │   │       ├── proc-macro2 v0.4.24 (*)
│   │   │       ├── quote v0.6.10 (*)
│   │   │       └── unicode-xid v0.1.0 (*)
│   │   ├── proc-macro2 v0.4.24 (*)
│   │   ├── quote v0.6.10 (*)
│   │   ├── syn v0.15.23 (*)
│   │   └── unindent v0.1.3
│   └── proc-macro-hack v0.5.4 (*)
├── lazy_static v1.2.0
└── regex v1.1.0
    ├── aho-corasick v0.6.9
    │   └── memchr v2.1.2
    │       ├── cfg-if v0.1.6
    │       └── libc v0.2.45 (*)
    │       [build-dependencies]
    │       └── version_check v0.1.5
    ├── memchr v2.1.2 (*)
    ├── regex-syntax v0.6.4
    │   └── ucd-util v0.1.3
    ├── thread_local v0.3.6
    │   └── lazy_static v1.2.0 (*)
    └── utf8-ranges v1.0.2

Each time i dig into some interesting topic while solving Advent Of Code puzzles. This time it was rust structs and method implementation for structs.

For tracking guard shift (see puzzle details) i introduced ShiftTimeline structure:

struct ShiftTimeline {
    data: Vec<u32>,
}

The idea was to keep minutes between the guard was sleeping in vector.

A struct, or structure, is a custom data type that lets you name and package together multiple related values that make up a meaningful group. If you’re familiar with an object-oriented language, a structis like an object’s data attributes. In this chapter, we’ll compare and contrast tuples with structs, demonstrate how to use structs, and discuss how to define methods and associated functions to specify behavior associated with a struct’s data. Structs and enums (discussed in Chapter 6) are the building blocks for creating new types in your program’s domain to take full advantage of Rust’s compile time type checking.

First i was going to add more properties but after all I left only one. Its does not makes much sense to keep structure for single field... But i decided to keep it in order to group methods around it. Reading the rust book about methods:

Methods are similar to functions: they’re declared with the fn keyword and their name, they can have parameters and a return value, and they contain some code that is run when they’re called from somewhere else. However, methods are different from functions in that they’re defined within the context of a struct, and their first parameter is always self, which represents the instance of the struct the method is being called on.

When used ShiftTimeline structure i found duplicated data initialization code:

let timeline = ShiftTimeline { data: Vec::new() };

So implemented simple initializer:

struct ShiftTimeline {
    data: Vec<u32>,
}

impl ShiftTimeline {
    fn new() -> ShiftTimeline {
        ShiftTimeline { data: Vec::new() }
    }
}

Now it is possible to use ShiftTimeline::new() to get property initialized. One more method accepting reference to self for write access to structure fields:

impl ShiftTimeline {

    ...

    fn record_sleep_time(&mut self, asleep_at: NaiveDateTime, awake_at: NaiveDateTime) {
       let start_min = asleep_at_time.minute();
       let end_min = awake_at.minute();
       for idx in start_min..end_min {
           self.data.push(idx);
       }
    }
}

...

shift_timeline.record_sleep_time(...)

The IDs abcde and axcye are close, but they differ by two characters (the second and fourth). However, the IDs fghij and fguij differ by exactly one character, the third (h and u). Those must be the correct boxes.

What letters are common between the two correct box IDs?

In order to compare ids I going to iteratively replace 1 char in all of them with 0 (which ins not part of original alphabet) and use results of replacement as hash keys while storing original ids to values for the key.

Pseudocode for solution:

ids = get_input_ids
hash = {}

for original_id in ids
  for id_with_1_char_replaced in combinations_with_1_char_replaced(original_id)
    hash[id_with_1_chars_replaced].push(original_id)

solution = hash.values.find { |arr| arr.any? }

def combinations_with_1_char_replaced(original)
    result = []
    
    original.len.times |idx|
         id_as_array = original.clone()
         id_as_array[idx0] = 0
         result.push(id_as_array.join)
   
    return result

Solution in rust:

use std::char;

fn part_two() {
    let input = utils::read_puzzle_input(2);
    let mut results: HashMap<String, Vec<_>> = HashMap::new();
    let mut lines_count = 0;
    let mut ids_count = 0;

    for id in input.lines() {
        let ids = all_valiants_with_1_letter_replaced(id);

        lines_count += 1;

        for id_changed in ids {
            ids_count += 1;
            results.entry(id_changed)
                .and_modify(|vec| vec.push(id.clone()))
                .or_insert(vec!(id));
        }
    }

    let mut res = vec!();

    for (matcher, ids) in &results {
        if ids.len() > 1 {
            res.push((matcher.clone(), ids.clone()));
        }
    }

    println!("{}", "-".repeat(100));

    for tup in &res {
        println!("{:?}", tup);
    }

    println!("{}", "-".repeat(100));

    println!("Res.len: {:?}", res.len());
    println!("Keys: {}", results.keys().len());
    println!("Values: {}", results.values().fold(0, |acc, arr| acc + arr.len()));
    println!("Lines: {}, ids: {}", lines_count, ids_count);
}


fn all_valiants_with_1_letter_replaced(id: &str) -> Vec<String> {
    let mut result: Vec<String> = vec!();
    let id_map = id.chars().collect::<Vec<char>>();
    let size = id.len();

    for idx in 0..size {
        let mut cur_map = id_map.clone();
        cur_map[idx] = '0';
        result.push(cur_map.into_iter().collect());
    }

    return result;
}

Running the code:

➜  aoc2018 git:(master) ✗ cargo run --bin 2
warning: unused manifest key: package.edition
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/2`
----------------------------------------------------------------------------------------------------
("cvgywxqubnuaefmsl0jdrpfzyi", ["cvgywxqubnuaefmsldjdrpfzyi", "cvgywxqubnuaefmslkjdrpfzyi"])
----------------------------------------------------------------------------------------------------
Res.len: 1
Keys: 6499
Values: 6500
Lines: 250, ids: 6500

What letters are common between the two correct box IDs?

Removing 0 from hash key: "cvgywxqubnuaefmsljdrpfzyi". Submitting.

Your puzzle answer was cvgywxqubnuaefmsljdrpfzyi. Both parts of this puzzle are complete! They provide two gold stars: **

The Code

Disclaimer

Doing puzzle #2 of advent of code challenge in Rust. The puzzle is pretty simple. Input looks like this:

mvgowxqubnhaefjslkjlrptzyi
pvgowlqubnhaefmslkjdrpteyi
ovgowoqubnhaefmslkjnrptzyi
cvgowxqubnrxefmslkjdrptzyo
cvgowxqubnhaefmsokjdrprzyf
cvgowxqubnhjeflslkjgrptzyi
...

The task is:

...count the number that have an ID containing exactly two of any letter and then separately count those with exactly three of any letter. You can multiply those two counts together to get [an answer]...

Pseudocode solution would look like:

for line in input
   counters = count_letters(line)

seen_two_letters = 0
seen_three_letters = 0

for counter in counters
   if counter.values.includes(2)
      seen_two_letters += 1
   if counter.values.include(3)
      seen_three_letters += 1

print seen_two_letters * seen_three_letters

Let's do it in rust. Without much optimization i going to use vector fo HashMaps to store char counts for each line. Then iterate over them and count hashes having 2 or 3 among values.

extern crate utils;
use std::collections::HashMap;

fn part_one() {
    let input = utils::read_puzzle_input(2);

    for line in input.lines() {
        let mut counters: HashMap<char, u8> = HashMap::new();

        for chr in line.chars() {
            match counters.get(&chr).cloned() {
                Some(count) => counters.insert(chr, count + 1),
                None => counters.insert(chr, 1),
            };
        }
    }
}

Running the code:

➜  aoc2018 git:(master) ✗ cargo run --bin 2
   Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
error[E0502]: cannot borrow `counters` as mutable because it is 
also borrowed as immutable
  --> src/bin/2.rs:57:32
   |
56 |             match counters.get(&chr) {
   |                   -------- immutable borrow occurs here
57 |                 Some(count) => counters.insert(chr, count + 1),
   |                                ^^^^^^^^ mutable borrow occurs here
58 |                 None => counters.insert(chr, 1),
59 |             };
   |             - immutable borrow ends here

error[E0502]: cannot borrow `counters` as mutable because it is 
also borrowed as immutable
  --> src/bin/2.rs:58:25
   |
56 |             match counters.get(&chr) {
   |                   -------- immutable borrow occurs here
57 |                 Some(count) => counters.insert(chr, count + 1),
58 |                 None => counters.insert(chr, 1),
   |                         ^^^^^^^^ mutable borrow occurs here
59 |             };
   |             - immutable borrow ends here

error: aborting due to 2 previous errors

For more information about this error, try `rustc --explain E0502`.
error: Could not compile `aoc2018`.

To learn more, run the command again with --verbose.

Re-reading topic on ownership and borrowing from Rust Book. The concept of ownership looks clear to me. Borrowing and mutable borrowing was not. For proper borrowing one should obey some rules:

First, any borrow must last for a scope no greater than that of the owner. Second, you may have one or the other of these two kinds of borrows, but not both at the same time: one or more references (&T) to a resource, exactly one mutable reference (&mut T).

So the problem is that i borrowed counters hash map for both reading and writing. Since HashMap#get returns an Option with reference to the value (stored in heap). At the same time counter.insert() borrowing hash data as mutable in order to modify hash data (in heap). Rust denies this in order to guarantee memory safety and avoid race conditions:

Ownership is how Rust achieves its largest goal, memory safety.

So one of approaches is to avoid borrowing hash value for reading is just copy the value. Documentation for Option gives helpful .cloned() method.

Maps an Option<&T> to an Option<T> by cloning the contents of the option.

I'll use the method when getting hash value:

fn part_one() {
    let input = utils::read_puzzle_input(2);

    for line in input.lines() {
        let mut counters: HashMap<char, u8> = HashMap::new();

        for chr in line.chars() {
            match counters.get(&chr).cloned() {
                Some(count) => counters.insert(chr, count + 1),
                None => counters.insert(chr, 1),
            };
        }

        println!("{:?}", counters.values());
    }
}

Running the code:

cargo run --bin 2
   Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
    Finished dev [unoptimized + debuginfo] target(s) in 0.62 secs
     Running `target/debug/2`
[1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1]
[1, 1, 2, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 2]
[1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1]
...

It worked. The only thing is i doing copy of value each time i need to avoid read only borrowing. One smart person suggested me to use HashMap#entry() in order to get hash Entry for in place modification. Entry itself has a lot of useful methods. Entry#and_modify() looks exactly what i need. Examples from docs:

use std::collections::HashMap;

let mut map: HashMap<&str, u32> = HashMap::new();

map.entry("poneyland")
   .and_modify(|e| { *e += 1 })
   .or_insert(42);

assert_eq!(map["poneyland"], 42);

Wow. I'll change my code a from this:

   for line in input.lines() {
        let mut counters: HashMap<char, u8> = HashMap::new();

        for chr in line.chars() {
            match counters.get(&chr).cloned() {
                Some(count) => counters.insert(chr, count + 1),
                None => counters.insert(chr, 1),
            };
        }
   }

to this:

    for line in input.lines() {
        let mut counters: HashMap<char, u8> = HashMap::new();

        for chr in line.chars() {
            counters
                .entry(chr)
                .and_modify(|count| { *count += 1})
                .or_insert(1);
        }
    }

Ok. Time to finish the AOC puzzle. I counted all letters in all ids. Now i need count:

...count the number that have an ID containing exactly two of any letter and then separately count those with exactly three of any letter. You can multiply those two counts together to get [an answer]...

# pseudocode

seen_two_letters = 0
seen_three_letters = 0

for counter in counters
   if counter.values.includes(2)
      seen_two_letters += 1
   if counter.values.include(3)
      seen_three_letters += 1

print seen_two_letters * seen_three_letters

Converting to rust:

extern crate utils;
use std::collections::HashMap;

fn part_one() {
    let input = utils::read_puzzle_input(2);
    let mut seen_two_letters_count = 0;
    let mut seen_three_letters_count = 0;

    for line in input.lines() {
        let mut counter: HashMap<char, u8> = HashMap::new();

        for chr in line.chars() {
            counter
                .entry(chr)
                .and_modify(|count| { *count += 1})
                .or_insert(1);
        }

        if counter.values().find(|v| { **v == 2 }).is_some() {
            seen_two_letters_count += 1;
        }

        if counter.values().find(|v| { **v == 3 }).is_some() {
            seen_three_letters_count += 1;
        }
    }

    println!("{}", seen_three_letters_count * seen_two_letters_count);
}

Running:

➜  aoc2018 git:(master) ✗ cargo run --bin 2
   Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
    Finished dev [unoptimized + debuginfo] target(s) in 0.62 secs
     Running `target/debug/2`
5368

The number accepted!

Your puzzle answer was 5368. The first half of this puzzle is complete! It provides one gold star: *

Disclaimer

use std::fs::File;
use std::io::prelude::*;

// TODO: Share between puzzles...
fn read_puzzle_input(number: u8) -> String {
    let mut input =
        File::open(format!("./inputs/{}.txt", number))
              .expect("Puzzle input not found...");

    let mut text = String::new();

    input
        .read_to_string(&mut text)
        .expect("cannot read input file");

    return text;
}

I going to move this function to separate file and then somehow reuse in all my solutions. Quick googling leads to "Using Modules to Reuse and Organize Code" of The Rust Book.

what happens if you have too many functions? Rust has a module system that enables the reuse of code in an organized fashion.

Nice! Two important things from first page:

• By default, functions, types, constants, and modules are private. The pub keyword makes an item public and therefore visible outside its namespace.
• The use keyword brings modules, or the definitions inside modules, into scope so it’s easier to refer to them.

Rust has pretty flexible module layout and there are some rules for module organization. For my simple case i just made following steps:

1. Moved function to external file `src/utils.rs`
2. prefixed function with pub keyword: pub fn read_puzzle_input...
3. and added small snippet to Cargo.toml:

[lib]
name = "utils"
path = "src/utils.rs"

Now in order to use functions from this library i need added crate declaration to top of my file and prefixed function call with utils namespace:

extern crate utils;

fn part_one() {
    let input = utils::read_puzzle_input(1);
    let mut result: i32 = 0;

    for line in input.lines() {
        let num = line.parse::<i32>().unwrap();
        result += num;
    }

    println!("Sum of freq adjustments: {}", result);
}

The Code.

Disclaimer

If You use blender as video editor you probably doing a lot of manual work to setup and rebuild strip proxies (Proxy/timecode) in Sequencer. Been there, tired to do that!

In order to build proxy for all you strips just paste this code in bledner text editor and press 'run script':

import bpy

def proxy_gen_all(proxy_sizes=[25], force=False):
    """ Rebuilds proxies for all strips"""
    
    for scene in bpy.data.scenes:
        seqs = scene.sequence_editor.sequences_all

        for seq in seqs:
            # operate only on MOVIE strips
            if seq.type == 'MOVIE':
                seq.use_proxy = True
            
                # if we pregenerate proxies in parallel externally
                if force:
                    seq.proxy.use_overwrite = True
                
                if 25 in proxy_sizes:
                    seq.proxy.build_25 = True

                if 50 in proxy_sizes:
                    seq.proxy.build_50 = True
                    
                if 75 in proxy_sizes:
                    seq.proxy.build_75 = True

                if 100 in proxy_sizes:
                    seq.proxy.build_100 = True
                
                seq.proxy.use_overwrite = False
    
    bpy.ops.sequencer.rebuild_proxy()
    
proxy_gen_all([25, 50])

The script will build 25% and 50% proxies for all strips. It will not rebuild proxies if you run it again. Proxy building is time consuming task and unfortunately it blocks blender UI. So if you want to force rebuild the proxies you can just replace last line with this:

proxy_gen_all([25, 50], True)

Second argument forces rebuild of all proxies.

Have fun!

In my first puzzle in advent of code challenge I used some copy/pasted rust code which was not completely clear to me... It's time to understand the code and document it here.

I talking about .expect and .unwrap() methods.

File::open() will throw compilation error without .expect() in copy/pasted code

File::open(filename).expect("error message");

Parse function will throw compilation error without .unwrap() call in copy/pasted code

line.parse::<i32>().unwrap();

From signature of std::fs::File::open() I see that it returns Result<File> instead of File. Googling leads to Error Handling topic in Rust Book which explains:

Rust doesn’t have exceptions. Instead, it has the type Result<T, E> for recoverable errors and the panic! macro that stops execution when the program encounters an unrecoverable error.

Result<T, E> is the type used for returning and propagating errors. It is an enum with the variants, Ok(T), representing success and containing a value, and Err(E), representing error and containing an error value.

Generic Result enum looks like this:

enum Result<T, E> {
   Ok(T),
   Err(E),
}

After getting result developer should handle Ok(result) or Err(why) situations. Typical error handling in rust looks like this:

use std::fs::File;
use std::error::Error;

fn main() {
    let path = ".gitignore";
    match File::open(&path) {
        Err(why) => panic!("couldn't open {}: {}", path, why.description()),
        Ok(file) => println!("{:?}", file),
    };
}

This is how rust book explains code above:

In the case where File::open succeeds, the value in [match construction] will be an instance of Ok that contains a file handle. In the case where it fails, the value in [match construction] will be an instance of Err that contains more information about the kind of error that happened.

Only one branch will be executed depending on operation result.

So what is purpose of .expect() in this code?

File::open(filename).expect("error message");

Looking at documentation for std::result::Result and seeing explanation:

Unwraps a result, yielding the content of an Ok. Panics if the value is an Err, with a panic message including the passed message, and the content of the Err.

So basically .expect() is a shorthand for match construction above. It either takes result or panics with message. I checked the code of std::result::Result and seeing this:

  #[inline]
  #[stable(feature = "result_expect", since = "1.4.0")]
  pub fn expect(self, msg: &str) -> T {
      match self {
          Ok(t) => t,
          Err(e) => unwrap_failed(msg, e),
      }
  }

Very similar to example with Result matching i gave above.

One more note from Rust Book:

Rust groups errors into two major categories: recoverable and unrecoverable errors. For a recoverable error, such as a file not found error, it’s reasonable to report the problem to the user and retry the operation. Unrecoverable errors are always symptoms of bugs, like trying to access a location beyond the end of an array.

.expect() makes unrecoverable error from recoverable. In simple cases it is okay to handle situation like this but production programs should not panic if file is missing or not readable.

.unwrap() is very similar to .expect:

Unwraps a result, yielding the content of an Ok. Panics if the value is an Err, with a panic message provided by the Err's value.

So difference from expect is only that expect takes additional error message.

Additional reading:

• Rust Book: Error Handling
• Rust By Example: Result
• std::result module documentation
• std::result::Result api

Disclaimer

Photo by Mike Baird (CC BY 2.0) Cropped.

This disclaimer related to Advent of code posts i publishing in this blog.

In those posts I going to document my travel into Rust programming language. The goal of these blog posts is to make my understanding of rust better as a result of documenting my findings and insights. Making public posts makes me more responsible: forces to think twice and read more docs before publishing in order to look less stupid than I am.

I have basic background in rust and made some small rusty experiments for myself. In terms of theory I had been reading interesting topics of The Rust Book a year ago.

The posts should not be considered as educational material or smart findings. Just personal notes of new rust developer.

Photo by Kevin Utting (CC BY 2.0) Cropped.

Solving part 2 of day 1 in advent of code challenge. Puzzle is based on day 1 part 1.

The task is:

You notice that the device repeats the same frequency change list over and over. To calibrate the device, you need to find the first frequency it reaches twice.

So taking a look to solution from part one:

fn main() {
    let input = read_puzzle_input(1);
    let mut result: i32 = 0;

    for line in input.lines() {
        let num = line.parse::<i32>().unwrap();
        result += num;
    }

    println!("{}", result);
}

The task looks like easy one: i just need to collect results and find first duplicate! First idea is to use array and then check wherever it includes current result on each iteration. But arrays search complexity is O(n) and it will slow down the code when i'll need too many iterations. Hash might be better here with O(1) access complexity. However hash should keep some kind of value which is not required for my task. So i need some kind of collection with inexpensive inserts and inclusion checks. Let's see what rust provide in standard library: collections.

Rust has 4 major categories of collections:

• Sequences: Vec, VecDeque, LinkedList
• Maps: HashMap, BTreeMap
• Sets: HashSet, BTreeSet
• Misc: BinaryHeap

The documentation is pretty nice and explains pros and cons of each type...

Use the Set variant of any of these Maps when:

You just want to remember which keys you've seen.

There is no meaningful value to associate with your keys.

You just want a set.

Looks like exactly what i need. There is an BTreeSet and a HashSet. I believe second is cheaper for inserts so i'll use it.

fn part_two() {
    let input = read_puzzle_input(1);
    let mut result: i32 = 0;
    let mut seen_freqs: HashSet<i32> = HashSet::new();

    seen_freqs.insert(result);

    for line in input.lines() {
        let num = line.parse::<i32>().unwrap();
        result += num;

        if !seen_freqs.insert(result) {
            println!("Repeating frequency: {}", result);
            break
        }
    }
}

Basically doing the same work as before but this time inserting each result to HashSet. Insert method returns boolean false if value is already in set.

Running this and getting no output.

I cant believe! Getting debug output (one result per line) and comparing using shell tools:

cargo run > nums.txt
wc -l nums.txt
989 nums.txt
uniq nums.txt > nums2.txt
wc -l nums2.txt
989 nums2.txt

Looks like the same number of unique values: no duplicates. Carefully rereading the task and seeing something i had missed first time:

Note that your device might need to repeat its list of frequency changes many times before a duplicate frequency is found, and that duplicates might be found while in the middle of processing the list.

Okay. It means I must iterate over lines again and wait for repeating number. But input.lines() returns Lines struct which is iterator so when it reach the end of sequence it will stop. First idea was to convert iterator to list and then use old good endless loop with index manipulation + break the loop once value found. However after digging in iterator docs i found a way to restart iterator: std::iter::iterator#cycle. input.lines() returns Lines struct which implements Iterator Trait. This fact probably means i can use cycle() to endlessly iterate over some values.

Adding .cycle() call on Lines:

fn part_two() {
    let input = read_puzzle_input(1);
    let mut result: i32 = 0;
    let mut seen_freqs: HashSet<i32> = HashSet::new();

    seen_freqs.insert(result);

    for line in input.lines().cycle() {
        let num = line.parse::<i32>().unwrap();
        result += num;

        if !seen_freqs.insert(result) {
            println!("Repeating frequency: {}", result);
            break
        }
    }
}

Running the code:

cargo run
   Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
    Finished dev [unoptimized + debuginfo] target(s) in 0.62 secs
     Running `target/debug/1`
Sum of freq adjustments: 493
Repeating frequency: 413

Submitting result:

That's the right answer! You are one gold star closer to fixing the time stream.

Code pushed to GitHub.

Findings

• Read requirements carefully :)
• Unix shell skills are still relevant
• Everything I need to know about iterators in rust on one page

Disclaimer

Photo by Paul VanDerWerf (CC BY 2.0) Cropped.

Motivation

One smart person motivated me to join Advent of Code challenge.

Here I going to document my travel into Rust programming language. The goal of this blog posts is to make my understanding of rust better as a result of documenting my insights. Making public posts makes me more responsible and forces to think twice and read more docs before publishing in order to look less stupid than I am.

I have basic background in rust making small experiments for myself. In terms of theory I had been reading interesting topics of The Rust Book a year ago.

This post will outline all setup steps i made in order to start. Next posts will probably have less instructions and more personal observations about rust.

Project Layout

First I installed rust using rustup tool. Easy one liner to get all i need.

Next i generated new project using awesome cargo tool:

cargo new aoc2018
cd aoc2018
tree .
.
├── Cargo.toml
└── src
    └── main.rs

1 directory, 2 files

Cargo is a built in package manager and build tool for Rust. It has more functionality than other package managers i used (gem, bundler, npm, pip). Here is incomplete list of tasks cargo can do for you:

• Generate new project
• Build your project and run tests
• Manage project dependencies specified in Cargo.toml
• Publish your package on crates.io
• Format your code

Other languages provide different tools for above mentioned tasks but approach taken by rust team makes it really easy to start without all those problems with moving parts.

Default generated code contains "Hello World" program and its as easy to run as:

cargo run  
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/aoc2018`
Hello, world!

Next I going to change my project layout to have one binary output for each puzzle.

Section about project layout in Cargo Book says that binaries should go to src/bin/*.rs.

Reorganizing the project:

cd src 
mkdir bin 
mv main.rs bin/1.rs
cd ../../
cargo run
   Compiling aoc2018 v0.1.0 (file:///private/tmp/aoc2018)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `/private/tmp/aoc2018/target/debug/1`
Hello, world!

Puzzle #1

It's time to get into code.

Making long story short: you getting list of newline separated numbers prefixed with plus or minus signs. Solution is sum of them. Input looks like:

+13
+9
+8
+1
-15
+10
...

I pasted this input to inputs/1.txt in root of the project. I going to put all inputs to the folder and want to create universal function to read these files. I'm too lazy to read the api docs but google gives good example from rust book.

Tailoring example to my needs:

use std::fs::File;
use std::io::prelude::*;

fn read_puzzle_input(number: u8) -> String {
    let mut input =
        File::open(format!("./inputs/{}.txt", number))
            .expect("Puzzle input not found...");
    let mut text = String::new();

    input
        .read_to_string(&mut text)
        .expect("cannot read input file");

    return text;
}

Ok. Now i going to iterate over lines, parse them and sum. Luckily rust has built in lines() method on String. This method returns Lines iterator which can be used in loops:

fn main() {
    let input = read_puzzle_input(1);

    for line in input.lines() {
        println!("{}", result);
    }
}

It was easy. Time to parse numbers. My first idea was to get sign from each line at position 0 and parse the rest of the string as integer. Then using match keyword either add or subtract from some variable. When i tried to parse integers i found that rust has str::parse method that converts strings to other types. Even easier than i thought!

fn main() {
    let input = read_puzzle_input(1);
    let mut result: i32 = 0;

    for line in input.lines() {
        let num = line.parse::<i32>().unwrap();
        result += num;
    }

    println!("{}", result);
}

Running the code:

 cargo run
   Compiling aoc2018 v0.1.0 (file:///Users/antono/Code/rust/aoc2018)
    Finished dev [unoptimized + debuginfo] target(s) in 0.92 secs
     Running `target/debug/1`
493

It works. Result accepted and i got first star in the challenge.

Awesome!

My code published on GitHub if someone cares.

Things to investigate

Some things in code still need to be explained to myself.

File::open() will throw compilation error without .expect()

File::open(filename).expect("error message");

Parse function will throw compilation error without .unwrap() call.

line.parse::<i32>().unwrap();

Using File looks obvious but why should i use prelude?

use std::fs::File;
use std::io::prelude::*;

I will document the answers in my next posts.

Disclaimer