feat: Add more slice methods to the stdlib

compiler/noirc_frontend/src/parser/parser.rs

@@ -48,7 +48,7 @@
 
 use chumsky::prelude::*;
 use iter_extended::vecmap;
 use lalrpop_util::lalrpop_mod;
 use noirc_errors::{Span, Spanned};
 
 mod assertion;
@@ -62,8 +62,8 @@
 mod traits;
 mod types;
 
 // synthesized by LALRPOP
 lalrpop_mod!(pub noir_parser);
 
 #[cfg(test)]
 mod test_helpers;
@@ -87,12 +87,12 @@
 
     if cfg!(feature = "experimental_parser") {
         for parsed_item in &parsed_module.items {
             if lalrpop_parser_supports_kind(&parsed_item.kind) {
                 match &parsed_item.kind {
                     ItemKind::Import(parsed_use_tree) => {
                         prototype_parse_use_tree(Some(parsed_use_tree), source_program);
                     }
                     // other kinds prevented by lalrpop_parser_supports_kind
                     _ => unreachable!(),
                 }
             }
@@ -109,7 +109,7 @@
     }
 
     let mut lexer = Lexer::new(input);
     lexer = lexer.skip_whitespaces(false);
     let mut errors = Vec::new();
 
     // NOTE: this is a hack to get the references working
@@ -1117,16 +1117,11 @@
 }
 
 fn quote() -> impl NoirParser<ExpressionKind> {
-    token_kind(TokenKind::Quote).validate(|token, span, emit| {
-        let tokens = match token {
+    token_kind(TokenKind::Quote).map(|token| {
+        ExpressionKind::Quote(match token {
             Token::Quote(tokens) => tokens,
             _ => unreachable!("token_kind(Quote) should guarantee parsing only a quote token"),
-        };
-        emit(ParserError::with_reason(
-            ParserErrorReason::ExperimentalFeature("quoted expressions"),
-            span,
-        ));
-        ExpressionKind::Quote(tokens)
+        })
     })
 }
 

docs/docs/noir/concepts/data_types/slices.mdx

@@ -197,7 +197,7 @@ fn main() {
 Applies a function to each element of the slice, returning a new slice containing the mapped elements.
 
 ```rust
-fn map<U>(self, f: fn(T) -> U) -> [U]
+fn map<U, Env>(self, f: fn[Env](T) -> U) -> [U]
 ```
 
 example
@@ -213,7 +213,7 @@ Applies a function to each element of the slice, returning the final accumulated
 parameter is the initial value.
 
 ```rust
-fn fold<U>(self, mut accumulator: U, f: fn(U, T) -> U) -> U
+fn fold<U, Env>(self, mut accumulator: U, f: fn[Env](U, T) -> U) -> U
 ```
 
 This is a left fold, so the given function will be applied to the accumulator and first element of
@@ -247,7 +247,7 @@ fn main() {
 Same as fold, but uses the first element as the starting element.
 
 ```rust
-fn reduce(self, f: fn(T, T) -> T) -> T
+fn reduce<Env>(self, f: fn[Env](T, T) -> T) -> T
 ```
 
 example:
@@ -260,12 +260,72 @@ fn main() {
 }
 ```
 
+### filter
+
+Returns a new slice containing only elements for which the given predicate returns true.
+
+```rust
+fn filter<Env>(self, f: fn[Env](T) -> bool) -> Self
+```
+
+example:
+
+```rust
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+}
+```
+
+### join
+
+Flatten each element in the slice into one value, separated by `separator`.
+
+Note that although slices implement `Append`, `join` cannot be used on slice
+elements since nested slices are prohibited.
+
+```rust
+fn join(self, separator: T) -> T where T: Append
+```
+
+example:
+
+```rust
+struct Accumulator {
+    total: Field,
+}
+
+// "Append" two accumulators by adding them
+impl Append for Accumulator {
+    fn empty() -> Self {
+        Self { total: 0 }
+    }
+
+    fn append(self, other: Self) -> Self {
+        Self { total: self.total + other.total }
+    }
+}
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5].map(|total| Accumulator { total });
+
+    let result = slice.join(Accumulator::empty());
+    assert_eq(result, Accumulator { total: 15 });
+
+    // We can use a non-empty separator to insert additional elements to sum:
+    let separator = Accumulator { total: 10 };
+    let result = slice.join(separator);
+    assert_eq(result, Accumulator { total: 55 });
+}
+```
+
 ### all
 
 Returns true if all the elements satisfy the given predicate
 
 ```rust
-fn all(self, predicate: fn(T) -> bool) -> bool
+fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool
 ```
 
 example:
@@ -283,7 +343,7 @@ fn main() {
 Returns true if any of the elements satisfy the given predicate
 
 ```rust
-fn any(self, predicate: fn(T) -> bool) -> bool
+fn any<Env>(self, predicate: fn[Env](T) -> bool) -> bool
 ```
 
 example:

docs/docs/noir/standard_library/append.md

@@ -0,0 +1,38 @@
+---
+title: Append Trait
+description:
+  The Append Trait abstracts over types that can be appended to
+keywords: [append, trait]
+---
+
+`Append` can abstract over types that can be appended to - usually container types:
+
+```rs
+trait Append {
+    fn empty() -> Self;
+
+    fn append(self, other: Self) -> Self;
+}
+```
+
+`Append` requires two methods:
+
+- `empty`: Constructs an empty value of `Self`.
+- `append`: Append two values together, returning the result.
+
+Additionally, it is expected that for any implementation:
+
+- `T::empty().append(x) == x`
+- `x.append(T::empty()) == x`
+
+---
+
+## Implementations
+
+```rs
+impl<T> Append for [T]
+```
+
+```rs
+impl Append for Quoted
+```

noir_stdlib/src/append.nr

@@ -0,0 +1,33 @@
+// Appends two values together, returning the result.
+//
+// An alternate name for this trait is `Monoid` if that is familiar.
+// If not, it can be ignored.
+//
+// It is expected that for any implementation:
+// - `T::empty().append(x) == x`
+// - `x.append(T::empty()) == x`
+trait Append {
+    fn empty() -> Self;
+    fn append(self, other: Self) -> Self;
+}
+
+impl<T> Append for [T] {
+    fn empty() -> Self {
+        &[]
+    }
+
+    fn append(self, other: Self) -> Self {
+        // Slices have an existing append function which this will resolve to.
+        self.append(other)
+    }
+}
+
+impl Append for Quoted {
+    fn empty() -> Self {
+        quote {}
+    }
+
+    fn append(self, other: Self) -> Self {
+        quote { $self $other }
+    }
+}

noir_stdlib/src/lib.nr

@@ -27,6 +27,7 @@ mod uint128;
 mod bigint;
 mod runtime;
 mod meta;
+mod append;
 
 // Oracle calls are required to be wrapped in an unconstrained function
 // Thus, the only argument to the `println` oracle is expected to always be an ident

noir_stdlib/src/slice.nr

@@ -1,3 +1,5 @@
+use crate::append::Append;
+
 impl<T> [T] {
     #[builtin(array_len)]
     pub fn len(self) -> u32 {}
@@ -85,6 +87,33 @@ impl<T> [T] {
         accumulator
     }
 
+    // Returns a new slice containing only elements for which the given predicate
+    // returns true.
+    pub fn filter<Env>(self, predicate: fn[Env](T) -> bool) -> Self {
+        let mut ret = &[];
+        for elem in self {
+            if predicate(elem) {
+                ret = ret.push_back(elem);
+            }
+        }
+        ret
+    }
+
+    // Flatten each element in the slice into one value, separated by `separator`.
+    pub fn join(self, separator: T) -> T where T: Append {
+        let mut ret = T::empty();
+
+        if self.len() != 0 {
+            ret = self[0];
+
+            for i in 1 .. self.len() {
+                ret = ret.append(separator).append(self[i]);
+            }
+        }
+
+        ret
+    }
+
     // Returns true if all elements in the slice satisfy the predicate
     pub fn all<Env>(self, predicate: fn[Env](T) -> bool) -> bool {
         let mut ret = true;

test_programs/compile_success_empty/slice_join/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "slice_join"
+type = "bin"
+authors = [""]
+compiler_version = ">=0.31.0"
+
+[dependencies]

test_programs/compile_success_empty/slice_join/src/main.nr

@@ -0,0 +1,16 @@
+use std::append::Append;
+
+fn main() {
+    let slice = &[1, 2, 3, 4, 5];
+
+    let odds = slice.filter(|x| x % 2 == 1);
+    assert_eq(odds, &[1, 3, 5]);
+
+    let odds_and_evens = append_three(odds, &[100], &[2, 4]);
+    assert_eq(odds_and_evens, &[1, 3, 5, 100, 2, 4]);
+}
+
+fn append_three<T>(one: T, two: T, three: T) -> T where T: Append {
+    // The last .append(T::empty()) should do nothing
+    one.append(two).append(three).append(T::empty())
+}