Implement new Concept Exercise: iterators

[workingjubilee]

This issue describes how to implement the iterator concept exercise for the Rust track.

Getting started

Please please please read the docs before starting. Posting PRs without reading these docs will be a lot more frustrating for you during the review cycle, and exhaust Exercism's maintainers' time. So, before diving into the implementation, please read up on the following documents:

• The features of v3.
• Rationale for v3.
• What are concept exercise and how they are structured?

Please also watch the following video:

• The Anatomy of a Concept Exercise.

Goal

Iterators are one of Rust's more versatile linguistic abstractions, so it is not possible to cover in a single exercise. This exercise has only the goal of covering the foundations of Iterator so that advanced usage can be covered in detail.

Learning objectives

Student should be able to...

• recognize some cases where they can use .iter()
• use .next() to advance the iterator manually
• use one Iterator method with a closure, such as fold, map, or filter
• use fold or collect to produce a single value
• recognize basic implications of iterator laziness (so a fold or collect is required)

Student may be able to...

• recognize Iterator is as or more performant than for loops

Out of scope

• zip, chain, flatten, and other multi-iterator methods
• skip, step_by, take_while, and other selective iteration methods

Concepts

• Iterator

Prerequisites

• methods and traits
• in particular method chaining
• the collection in use (probably vec or String)
• some awareness of what an expression actually does
• some awareness of what a closure is like and/or higher-order functions
• if using filter: booleans and predicates

Resources to refer to

Hints

• std::iter::Iterator
• Rust by Example: Iterators
• The Rust Programming Language: Processing Items with a Series of Iterators

After

• TRPL on iterator performance
• Hoverbear going in-depth on iterators

Likely better for later exercises, but relevant:

• The itertools crate for Even More Fun
• Llogiq on performance

Representer

This should require no special changes to the representer.

Analyzer

This should require no special changes to the analyzer.

Implementing

See our implementation guide for guidance. . You may want to make use of boil_exercise.sh in the concept directory

Help

If you have any questions while implementing the exercise, please post the questions as comments in this issue.

[ghost]

Found Tim McNamara's video tutorial which would be a great intermediate / continue learning post: https://tim.mcnamara.nz/post/618982870485172224/rust-iteration.

[gilescope]

Would luhn work well for this concept?

personally I would change the spec to allow single character numbers so that the implementation is slightly nicer when done as a single expression.

[ghost]

@gilescope I feel we'll only know by trying! So if you are up for it, give it a whirl! For concept exercises I am unsure of how it will go and don't want to waste time on Exercism specific metadata, I have used a draft PR with a single example.rs. exercism/v3#3061 is an example.

[gilescope]

Actually I think maybe we should aim for a functional rust track where each answer is expected to be one expression and the tasks getting gradually harder as we introduce different things. For example lune should be targeting as a showcase for try_fold.

[nahuakang]

@coriolinus I wouldn't mind working on this next (both the concept and concept exercise). But it seems like we should have covered the trait concept before building out iterator? Do you have an opinion what would be the concepts/concept exercises that should be ready before working on iterator? I'd be happy to work on those first and eventually cover this issue.

[coriolinus]

It looks to me as though this concept is about using iterators, not defining them. I'm not sure how useful it would be to require knowledge of traits first. My instinct is that it should be OK to have this concept depend solely on the methods concept, and then have students implement a generator (via the Iterator trait) as part of the traits concept, which naturally would then come after this one.

We have to mention in the concept documentation that it is a trait, but I think it's OK to defer further explanation for later.

On Thu, May 5, 2022, 16:35 Nahua @.***> wrote:

@coriolinus https://github.com/coriolinus I wouldn't mind working on this next (both the concept and concept exercise). But it seems like we should have covered the trait concept before building out iterator? Do you have an opinion what would be the concepts/concept exercises that should be ready before working on iterator? I'd be happy to work on those first and eventually cover this issue.

— Reply to this email directly, view it on GitHub https://github.com/exercism/rust/issues/1065#issuecomment-1118631214, or unsubscribe https://github.com/notifications/unsubscribe-auth/AB3V4TXCYNJNE4VX53V7GPLVIPMCJANCNFSM4WXPOFKA . You are receiving this because you were mentioned.Message ID: @.***>

[nahuakang]

Happy to claim this if you assign it to me. Shall I also create an issue for the trait concept exercise?

[coriolinus]

Sounds good! Please do create a traits concept issue.

[senekor]

After several failed attempts to create a high-quality syllabus, I believe any future attempts will have to do their own design work from scratch.