Clean up: Array to buffer as Buffer.fromArray, (not Array.buffer). (#389)

* array to buffer.

* experiment.

* experiment concluded.

* review comments.

* remove old impl (again); git goof.

* review comments.

Author: matthewhammer

src/Array.mo

@@ -297,11 +297,4 @@ module {
     });
   };
 
-  public func buffer<A>(xs : [A]) : Buffer.Buffer<A> {
-    let buff = Buffer.Buffer<A>(xs.size());
-    for (x in xs.vals()) {
-      buff.add(x)
-    };
-    buff
-  };
 }

src/Buffer.mo

@@ -146,4 +146,21 @@ module {
     };
   };
 
+  /// Creates a buffer from immutable array elements.
+  public func fromArray<X>(elems : [X]) : Buffer<X> {
+    let buff = Buffer<X>(elems.size());
+    for (elem in elems.vals()) {
+      buff.add(elem)
+    };
+    buff
+  };
+
+  /// Creates a buffer from the elements of a mutable array.
+  public func fromVarArray<X>(elems : [var X]) : Buffer<X> {
+    let buff = Buffer<X>(elems.size());
+    for (elem in elems.vals()) {
+      buff.add(elem)
+    };
+    buff
+  };
 }

test/arrayTest.mo

@@ -216,11 +216,6 @@ let suite = Suite.suite("Array", [
     "reverse",
     Array.reverse<Nat>([0, 1, 2, 3]),
     M.equals(T.array<Nat>(T.natTestable, [3, 2, 1, 0]))
-  ),
-  Suite.test(
-    "buffer",
-    Array.buffer<Nat>([0, 1, 2, 3]).toArray(),
-    M.equals(T.array<Nat>(T.natTestable, [0, 1, 2, 3]))
   )
 ]);
 

test/bufTest.mo

@@ -3,6 +3,10 @@ import B "mo:base/Buffer";
 import I "mo:base/Iter";
 import O "mo:base/Option";
 
+import Suite "mo:matchers/Suite";
+import T "mo:matchers/Testable";
+import M "mo:matchers/Matchers";
+
 // test repeated growing
 let a = B.Buffer<Nat>(3);
 for (i in I.range(0, 123)) {
@@ -92,3 +96,18 @@ do {
   assert (c.toArray().size() == 2);
   assert (c.toVarArray().size() == 2);
 };
+
+let {run;test;suite} = Suite;
+run(suite("array",
+[
+  test(
+    "fromArray",
+    B.fromArray<Nat>([0, 1, 2, 3]).toArray(),
+    M.equals(T.array<Nat>(T.natTestable, [0, 1, 2, 3]))
+  ),
+  test(
+    "fromVarArray",
+    B.fromVarArray<Nat>([var 0, 1, 2, 3]).toArray(),
+    M.equals(T.array<Nat>(T.natTestable, [0, 1, 2, 3]))
+  )
+]));