Try out funcarray

Cargo.toml

@@ -2,6 +2,7 @@
 members = [
     "core",
     "cli",
+    "funcarray",
     "lsp/nls",
     "lsp/lsp-harness",
     "utils",
@@ -22,6 +23,7 @@ readme = "README.md"
 
 [workspace.dependencies]
 nickel-lang-core = { version = "0.9.0", path = "./core", default-features = false }
+nickel-lang-funcarray = { version = "0.1.0", path = "./funcarray" }
 nickel-lang-utils = { version = "0.1.0", path = "./utils" }
 lsp-harness = { version = "0.1.0", path = "./lsp/lsp-harness" }
 

core/Cargo.toml

@@ -43,6 +43,7 @@ codespan.workspace = true
 codespan-reporting.workspace = true
 cxx = { workspace = true, optional = true }
 logos.workspace = true
+nickel-lang-funcarray.workspace = true
 smallvec.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true
@@ -82,7 +83,6 @@ tree-sitter-nickel = { workspace = true, optional = true }
 
 metrics = { workspace = true, optional = true }
 strsim = "0.10.0"
-rpds = { version = "1.1.0", features = ["serde"] }
 
 [dev-dependencies]
 pretty_assertions.workspace = true

core/benches/arrays.rs

@@ -20,7 +20,10 @@ fn ncl_random_array(len: usize) -> String {
         numbers.push(RichTerm::from(Term::Num(Number::from(acc))));
     }
 
-    let xs = RichTerm::from(Term::Array(Array::new(numbers), ArrayAttrs::default()));
+    let xs = RichTerm::from(Term::Array(
+        Array::collect(numbers.into_iter()),
+        ArrayAttrs::default(),
+    ));
     let doc: DocBuilder<_, ()> = xs.pretty(&BoxAllocator);
     let mut out = Vec::new();
     doc.render(80, &mut out).unwrap();

core/src/cache.rs

@@ -605,7 +605,10 @@ impl Cache {
                     ))
                 } else {
                     Ok((
-                        attach_pos(Term::Array(Array::new(terms), Default::default()).into()),
+                        attach_pos(
+                            Term::Array(Array::collect(terms.into_iter()), Default::default())
+                                .into(),
+                        ),
                         ParseErrors::default(),
                     ))
                 }

core/src/closurize.rs

@@ -191,13 +191,12 @@ impl Closurize for Array {
         env: Environment,
         btype: BindingType,
     ) -> Self {
-        self.iter()
+        self.into_iter()
             .map(|t| {
                 if should_share(&t.term) {
-                    t.clone()
-                        .closurize_as_btype(cache, env.clone(), btype.clone())
+                    t.closurize_as_btype(cache, env.clone(), btype.clone())
                 } else {
-                    t.clone()
+                    t
                 }
             })
             .collect()

core/src/eval/mod.rs

@@ -807,8 +807,8 @@ impl<R: ImportResolver, C: Cache> VirtualMachine<R, C> {
                 // See the comment on the `BinaryOp::ArrayConcat` match arm.
                 Term::Array(terms, attrs) if !attrs.closurized => {
                     let closurized_array = terms
-                        .iter()
-                        .map(|t| t.clone().closurize(&mut self.cache, env.clone()))
+                        .into_iter()
+                        .map(|t| t.closurize(&mut self.cache, env.clone()))
                         .collect();
 
                     let closurized_ctrs = attrs
@@ -1274,8 +1274,8 @@ pub fn subst<C: Cache>(
         }
         Term::Array(ts, mut attrs) => {
             let ts = ts
-                .iter()
-                .map(|t| subst(cache, t.clone(), initial_env, env))
+                .into_iter()
+                .map(|t| subst(cache, t, initial_env, env))
                 .collect();
 
             // cd [^subst-closurized-false]