list-ops: add exercise (#2023)

Co-Authored-By: Remo Senekowitsch <[email protected]>

Author: ellnix

config.json

@@ -1194,6 +1194,19 @@
           "traits"
         ]
       },
+      {
+        "slug": "list-ops",
+        "name": "List Ops",
+        "uuid": "4b411941-d272-4b95-8c40-5816fecf27a2",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4,
+        "topics": [
+          "generics",
+          "iterators",
+          "traits"
+        ]
+      },
       {
         "slug": "phone-number",
         "name": "Phone Number",

exercises/practice/list-ops/.docs/instructions.append.md

@@ -0,0 +1,13 @@
+# Instructions append
+
+## Implementing your own list operations
+
+Rust has a rich iterator system, using them to solve this exercise is trivial.
+Please attempt to solve the exercise without reaching for iterator methods like 
+`map()`, `flatten()`, `filter()`, `count()`, `fold()`, `chain()`, `rev()` and similar.
+The `next()` and `next_back()` methods do not count.
+
+## Avoiding allocations
+
+The exercise is solvable without introducing any additional memory allocations in the solution.
+See if you can create your own iterator type instead of creating an iterator from a collection.

exercises/practice/list-ops/.docs/instructions.md

@@ -0,0 +1,19 @@
+# Instructions
+
+Implement basic list operations.
+
+In functional languages list operations like `length`, `map`, and `reduce` are very common.
+Implement a series of basic list operations, without using existing functions.
+
+The precise number and names of the operations to be implemented will be track dependent to avoid conflicts with existing names, but the general operations you will implement include:
+
+- `append` (_given two lists, add all items in the second list to the end of the first list_);
+- `concatenate` (_given a series of lists, combine all items in all lists into one flattened list_);
+- `filter` (_given a predicate and a list, return the list of all items for which `predicate(item)` is True_);
+- `length` (_given a list, return the total number of items within it_);
+- `map` (_given a function and a list, return the list of the results of applying `function(item)` on all items_);
+- `foldl` (_given a function, a list, and initial accumulator, fold (reduce) each item into the accumulator from the left_);
+- `foldr` (_given a function, a list, and an initial accumulator, fold (reduce) each item into the accumulator from the right_);
+- `reverse` (_given a list, return a list with all the original items, but in reversed order_).
+
+Note, the ordering in which arguments are passed to the fold functions (`foldl`, `foldr`) is significant.

exercises/practice/list-ops/.gitignore

@@ -0,0 +1,8 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+**/*.rs.bk
+
+# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
+# More information here http://doc.crates.io/guide.html#cargotoml-vs-cargolock
+Cargo.lock

exercises/practice/list-ops/.meta/config.json

@@ -0,0 +1,16 @@
+{
+  "authors": ["ellnix"],
+  "files": {
+    "solution": [
+      "src/lib.rs",
+      "Cargo.toml"
+    ],
+    "test": [
+      "tests/list-ops.rs"
+    ],
+    "example": [
+      ".meta/example.rs"
+    ]
+  },
+  "blurb": "Implement basic list operations."
+}

exercises/practice/list-ops/.meta/example.rs

@@ -0,0 +1,154 @@
+pub fn append<T, I>(a: I, b: I) -> impl Iterator<Item = T>
+where
+    I: Iterator<Item = T>,
+{
+    struct Append<T, I: Iterator<Item = T>> {
+        a: I,
+        b: I,
+    }
+
+    impl<T, I: Iterator<Item = T>> Iterator for Append<T, I> {
+        type Item = T;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.a.next().or_else(|| self.b.next())
+        }
+    }
+
+    Append { a, b }
+}
+
+pub fn concat<I, NI, T>(list: I) -> impl Iterator<Item = T>
+where
+    NI: Iterator<Item = T>,
+    I: Iterator<Item = NI>,
+{
+    struct Concat<I: Iterator<Item = NI>, NI: Iterator<Item = T>, T> {
+        nested_list: I,
+        cur: Option<NI>,
+    }
+
+    impl<I: Iterator<Item = NI>, NI: Iterator<Item = T>, T> Iterator for Concat<I, NI, T> {
+        type Item = T;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            if let Some(nested_iterator) = self.cur.as_mut() {
+                if let Some(val) = nested_iterator.next() {
+                    return Some(val);
+                }
+            }
+
+            if let Some(next_nested) = self.nested_list.next() {
+                self.cur = Some(next_nested);
+                self.next()
+            } else {
+                None
+            }
+        }
+    }
+
+    Concat {
+        nested_list: list,
+        cur: None,
+    }
+}
+
+pub fn filter<I, T, F>(list: I, predicate: F) -> impl Iterator<Item = T>
+where
+    I: Iterator<Item = T>,
+    F: Fn(&T) -> bool,
+{
+    struct Filter<I: Iterator<Item = T>, T, F: Fn(&T) -> bool> {
+        list: I,
+        predicate: F,
+    }
+
+    impl<I, T, F> Iterator for Filter<I, T, F>
+    where
+        I: Iterator<Item = T>,
+        F: Fn(&T) -> bool,
+    {
+        type Item = T;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.list.find(|val| (self.predicate)(val))
+        }
+    }
+
+    Filter { list, predicate }
+}
+
+pub fn length<I: Iterator<Item = T>, T>(list: I) -> usize {
+    let mut len = 0;
+
+    for _ in list {
+        len += 1;
+    }
+
+    len
+}
+
+pub fn map<I, F, T, U>(list: I, function: F) -> impl Iterator<Item = U>
+where
+    I: Iterator<Item = T>,
+    F: Fn(T) -> U,
+{
+    struct Map<I: Iterator<Item = T>, F: Fn(T) -> U, T, U> {
+        list: I,
+        function: F,
+    }
+
+    impl<I: Iterator<Item = T>, F: Fn(T) -> U, T, U> Iterator for Map<I, F, T, U> {
+        type Item = U;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.list.next().map(&self.function)
+        }
+    }
+
+    Map { list, function }
+}
+
+pub fn foldl<I, F, T, U>(list: I, initial: U, function: F) -> U
+where
+    I: Iterator<Item = T>,
+    F: Fn(U, T) -> U,
+{
+    let mut result = initial;
+
+    for item in list {
+        result = (function)(result, item)
+    }
+
+    result
+}
+
+pub fn foldr<I, F, T, U>(mut list: I, initial: U, function: F) -> U
+where
+    I: DoubleEndedIterator<Item = T>,
+    F: Fn(U, T) -> U,
+{
+    let mut result = initial;
+
+    while let Some(item) = list.next_back() {
+        result = (function)(result, item)
+    }
+
+    result
+}
+
+pub fn reverse<I: DoubleEndedIterator<Item = T>, T>(list: I) -> impl Iterator<Item = T> {
+    struct Reverse<I: DoubleEndedIterator<Item = T>, T> {
+        list: I,
+    }
+
+    impl<I: DoubleEndedIterator<Item = T>, T> Iterator for Reverse<I, T> {
+        type Item = T;
+
+        fn next(&mut self) -> Option<Self::Item> {
+            self.list.next_back()
+        }
+    }
+
+    Reverse { list }
+}

exercises/practice/list-ops/.meta/test_template.tera

@@ -0,0 +1,78 @@
+use list_ops::*;
+
+{% for group in cases %}
+
+{% set first_exercise = group.cases | first %}
+{% if first_exercise.property == "concat" %}
+#[allow(clippy::zero_repeat_side_effects)]
+{%- endif %}
+mod {{ first_exercise.property | make_ident }} {
+    use super::*;
+
+{% for test in group.cases %}
+
+#[test]
+#[ignore]
+fn {{ test.description | make_ident }}() {
+{% filter replace(from="[", to="vec![") %}
+
+    {%- for arg, value in test.input -%}
+    {% if arg == "function" %}{% continue %}{% endif %}
+    {%- set is_empty = value is iterable and value | length == 0 -%}
+
+    let {{arg}} = 
+        {% if is_empty %}
+            {% if test.property is starting_with("fold") %}
+                [0.0f64; 0]
+            {% elif test.property == "concat" %}
+                [[0i32; 0]; 0]
+            {% else %}
+                [0i32; 0]
+            {% endif %}
+        {% elif test.property is starting_with("fold") %}
+            {% if value is number %}
+                {{ test.input[arg] }}.0
+            {% else %}
+                {{ test.input[arg] | as_str | replace(from=",", to=".0,") | replace(from="]", to=".0]") | replace(from="[.0]", to="[]") }}
+            {% endif %}
+        {% else %}
+            {{ test.input[arg] }}
+        {% endif -%}
+            {% if value is iterable %}
+                .into_iter()
+                {% set first_item = value | first %}
+                {% if test.property == "concat" or first_item is iterable %}
+                .map(Vec::into_iter)
+                {% endif %}
+            {% endif %};
+    {%- endfor -%}
+
+    let output = {{ test.property }}(
+        {% for arg, value in test.input %}
+        {% if arg == "function" %}
+            {{ value | replace(from="(", to="|") | replace(from=")", to="|") | replace(from=" ->", to="") | replace(from="modulo", to="%")}},
+        {% else %}
+            {{arg}},
+        {% endif %}
+        {% endfor %}
+    );
+
+    let expected = {{ test.expected }}{% if test.property is starting_with("fold") %}.0{% endif %};
+
+    assert_eq!(
+        output
+        {% if test.expected is iterable %}
+        {% set first_item = test.expected | first %}
+        {% if test.property != "concat" and first_item is iterable %}
+        .map(|subiter| subiter.collect::<Vec<_>>())
+        {% endif %}
+        .collect::<Vec<_>>()
+        {% endif %}, 
+      expected
+    );
+
+{% endfilter %}
+    }
+{% endfor -%}
+}
+{% endfor -%}