I want to add https://allcontributors.org/ support, but their bot doesn't support any kind of bulk add so I have to @ people who've previously contributed explicitly here. If you get mentioned here, take it as a special thanks from me to you to help make this piece of software a bit better!

There are several new concepts in the arc1.rs exercise, and I wonder if it would be useful to have a few gentle lead ins before this exercise.

In particular threads are a big leap in complexity with some new syntax (closures).

It would also be helpful to know what the arc1 code is trying to do in the first place. Reverse engineering the logic (with known missing lines of code) and figuring out threads and figuring out Arc, seems like too much for one exercise.

Proposal to add introductory section

The first exercise in the section successfully compiles to acclimate new users to Rustlings and introduce the I AM NOT DONE comment.

The second exercise simply asks the user to complete a Hello World! program.

The intro section is more to introduce Rustlings than to teach Rust.

Something like this, maybe:

// Make this compile!

use std::sync::Arc;
use std::thread;

struct JobStatus {
    jobs_completed: u32,
}

fn main() {
    let status = Arc::new(JobStatus { jobs_completed: 0 });
    let status_shared = status.clone();
    thread::spawn(move || {
        for _ in 0..10 {
            thread::sleep_ms(500);
            status_shared.jobs_completed += 1;
        }
    });
    while status.jobs_completed < 10 {
        println!("waiting...");
        thread::sleep_ms(1000);
    }
}

The following error appears when installing rustlings with provided script curl -L https://git.io/rustlings | bash the rustlings executable is installed successfully tho. Please give it a check.

=============================== Traceback (most recent call last): File "", line 1, in File "/opt/anaconda3/lib/python3.7/json/init.py", line 296, in load parse_constant=parse_constant, object_pairs_hook=object_pairs_hook, **kw) File "/opt/anaconda3/lib/python3.7/json/init.py", line 348, in loads return _default_decoder.decode(s) File "/opt/anaconda3/lib/python3.7/json/decoder.py", line 337, in decode obj, end = self.raw_decode(s, idx=_w(s, 0).end()) File "/opt/anaconda3/lib/python3.7/json/decoder.py", line 355, in raw_decode raise JSONDecodeError("Expecting value", s, err.value) from None json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0) Checking out version ... error: pathspec 'tags/' did not match any file(s) known to git

Breaking change. This removes hints from the end of files, and puts them into info.toml. You can now access hints using:

rustlings hint <exerciseName>

ALSO this changes the exercise system to index by name for run and hint, so:

rustlings run exercises/if/if1.rs

becomes

rustlings run if1

I must've missed a step in installing rustlings, I am using windows 10 and ran all of the commands to install and when I ran the 'rustlings' command it seems that it doesn't know what it is. I tried editing the PATH's but it still doesn't seem to work.

Exercises are not organized in order for rustlings watch and it was hard to follow the exercises because we always had to jump back and forth between chapters.

1. Updated exercise order to match that of book chapters
2. Added exercise to book chapter mapping table to exercise README.md

This change makes it possible to finish the last exercise without touching the test code, seems like an overlook when code was added since there's nothing in the hints about this extension neither.

It's virtually impossible to write a the num_sq function to take the Box since it doesn't implement MulAssign.

This enables analyzers to work correctly as if the exercises folder were a true Cargo project.

• It is an "orphan" Cargo.toml, completely unrelated to the root Cargo.toml. This has pros and cons.
  • It could be potentially confusing to learners, since they have to open the exercises folder for the analyzer to work.
  • OTOH it does not "infect" the main project build with tons of targets, many of them in a non-compilable state.
• The folder structure is unchanged! :tada:

This pull request adds exercises for converting values into specific types. The exercises uses string to struct type conversions, but most of the traits in the exercises can handle more than just string parsing and conversions.

The following traits are covered:

1. From and Into
2. TryFrom and TryInto
3. AsRef
4. FromStr

The as operator is also covered.

Noticed that the percent of exercises completed did not update in the progress bar when the sub-commands verify or watch were run. The percentage would update when working through the exercises - when the loop section section of the watch routine in src/main.rs had been entered.

Fixed the verify function in src/verify.rs so that the percentage would update by counting the number of exercises verified. A cleaner solution would be to use the percent key in the progress bar template (https://docs.rs/indicatif/latest/indicatif/index.html#templates) to implicitly change the progress percentage instead of explicitly manipulating the message to display the progress percentage. The percent key, however, does not show any digits after the decimal point (maybe another feature to implement there).

PS. First time contributing to a public project. Please point out if there are any deficiencies in the PR.

Thank you

While working on exercises/conversions/as_ref_mut.rs, I thought it would be helpful to add an exercise to generalize the num_sq() function to work with any numeric type. The process of making that change gave me a better understanding of the syntax for trait bounds.

The new exercise led to creating "as_mut2.rs", which, in turn, led to refactoring "as_ref_mut.rs" into "as_ref.rs" and "as_mut1.rs".

Apologies in advance for bumping into Frosthage's change (https://github.com/rust-lang/rustlings/pull/1113) which updates the hint for "as_ref_mut.rs". This change incorporates the change into "as_mut1.rs" instead.

Attempts to close #1298

• program verifies that threads have been joined by checking if results vector has been filled
• solution now involves recognizing that JoinHandle::join returns a Result, unpacking it, and adding the value to a vector

exercises > conversions > try_from_into.rs

impl TryFrom<(i16, i16, i16)> for Color { type Error = IntoColorError; fn try_from(tuple: (i16, i16, i16)) -> Result<Self, Self::Error> { let (r, g, b) = tuple; if r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 { return Err(IntoColorError::IntConversion); } // i didn't write else yet } }

compiler error:

! Compiling of exercises/conversions/try_from_into.rs failed! Please try again. Here's the output: error[E0317]: if may be missing an else clause --> exercises/conversions/try_from_into.rs:41:9 | 41 | / if r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 { 42 | | return Err(IntoColorError::IntConversion); 43 | | } | |_________^ expected (), found enum Result ( << this part ) | = note: expected unit type () found enum Result<Color, IntoColorError> = note: if expressions without else evaluate to () = help: consider adding an else block that evaluates to the expected type

error: aborting due to previous error

it says that it expected (), not Result.

seems like something is wrong.

when I write else {}, it says it expected Result and found (), and this is correct error.

It seems to me that the panic check in exercise threads1 is incomplete.

Here's the exercise:

// threads1.rs
// Execute `rustlings hint threads1` or use the `hint` watch subcommand for a hint.
// This program should wait until all the spawned threads have finished before exiting.

// I AM NOT DONE

use std::thread;
use std::time::Duration;


fn main() {

    let mut handles = vec![];
    for i in 0..10 {
        thread::spawn(move || {
            thread::sleep(Duration::from_millis(250));
            println!("thread {} is complete", i);
        });
    }

    let mut completed_threads = 0;
    for handle in handles {
        // TODO: a struct is returned from thread::spawn, can you use it?
        completed_threads += 1;
    }

    if completed_threads != 10 {
        panic!("Oh no! All the spawned threads did not finish!");
    }
    
}

The solution (at least mine) is to add each thread to handles in the first loop and join each handle in the second loop like in the block below. The issue is that the panic check actually always succeeds, even if the handles are not joined. I think it should panic if some of the threads are not finished.

// threads1.rs
// Execute `rustlings hint threads1` or use the `hint` watch subcommand for a hint.
// This program should wait until all the spawned threads have finished before exiting.

// I AM NOT DONE

use std::thread;
use std::time::Duration;


fn main() {

    let mut handles = vec![];
    for i in 0..10 {
        handles.push(thread::spawn(move || { // <- push handle to handles so you can track it
            thread::sleep(Duration::from_millis(250));
            println!("thread {} is complete", i);
        }));
    }

    let mut completed_threads = 0;
    for handle in handles {
        // TODO: a struct is returned from thread::spawn, can you use it?
        handle.join();          // <- code happily compiles and runs without this
        completed_threads += 1;
    }

    if completed_threads != 10 { // <- this condition is never met
        panic!("Oh no! All the spawned threads did not finish!");
    }
    
}

Upon trying to find how to alter the exercise I quickly discovered it's not easy to change without convoluting the whole thing, so maybe this was more of a conscious decision than a bug.

I tried to come up with an alteration to the exercise and this is my best attempt. I don't think it's great as it introduces adding an empty result to a vector, which doesn't really make much sense.

// threads1.rs
// Execute `rustlings hint threads1` or use the `hint` watch subcommand for a hint.
// This program should wait until all the spawned threads have finished before exiting.

// I AM NOT DONE

use std::thread;
use std::time::Duration;


fn main() {

    let mut handles = vec![];
    for i in 0..10 {
        thread::spawn(move || {
            thread::sleep(Duration::from_millis(250));
            println!("thread {} is complete", i);
        });
    }

    let mut results = vec![];
    for handle in handles {
        // TODO: a struct is returned from thread::spawn, can you use it?
    }


    if results.len()!= 10 {
        panic!("Oh no! All the spawned threads did not finish!");
    }
}