More pure/Queue improvements

src/Queue.mo

@@ -43,19 +43,66 @@
 import Iter "Iter";
 import Order "Order";
 import Types "Types";
+import PureQueue "pure/Queue";
 
 module {
   public type Queue<T> = Types.Queue.Queue<T>;
 
   type Node<T> = Types.Queue.Node<T>;
 
-  // public func toPure<T>(queue : Queue<T>) : PureQueue.Queue<T> {
-  //   todo();
-  // };
+  /// Converts a mutable queue to an immutable, purely functional queue.
+  ///
+  /// Example:
+  /// ```motoko
+  /// import Queue "mo:base/Queue";
+  ///
+  /// persistent actor {
+  ///   let queue = Queue.fromIter<Nat>([1, 2, 3].values());
+  ///   let pureQueue = Queue.toPure<Nat>(queue);
+  /// }
+  /// ```
+  ///
+  /// Runtime: O(n)
+  /// Space: O(n)
+  /// `n` denotes the number of elements stored in the queue.
+  public func toPure<T>(queue : Queue<T>) : PureQueue.Queue<T> {
+    let pureQueue = PureQueue.empty<T>();
+    let iter = values(queue);
+    var current = pureQueue;
+    loop {
+      switch(iter.next()) {
+        case null { return current };
+        case (?val) { current := PureQueue.pushBack(current, val) };
+      };
+    };
+  };
 
-  // public func fromPure<T>(queue : PureQueue.Queue<T>) : Queue<T> {
-  //   todo();
-  // };
+  /// Converts an immutable, purely functional queue to a mutable queue.
+  ///
+  /// Example:
+  /// ```motoko
+  /// import Queue "mo:base/Queue";
+  /// import PureQueue "mo:base/pure/Queue";
+  ///
+  /// persistent actor {
+  ///   let pureQueue = PureQueue.fromIter<Nat>([1, 2, 3].values());
+  ///   let queue = Queue.fromPure<Nat>(pureQueue);
+  /// }
+  /// ```
+  ///
+  /// Runtime: O(n)
+  /// Space: O(n)
+  /// `n` denotes the number of elements stored in the queue.
+  public func fromPure<T>(pureQueue : PureQueue.Queue<T>) : Queue<T> {
+    let queue = empty<T>();
+    let iter = PureQueue.values(pureQueue);
+    loop {
+      switch(iter.next()) {
+        case null { return queue };
+        case (?val) { pushBack(queue, val) };
+      };
+    };
+  };
 
   /// Create a new empty mutable double-ended queue.
   ///

src/pure/Queue.mo

@@ -25,7 +25,7 @@ import List "List";
 import Order "../Order";
 import Types "../Types";
 
-module Queue {
+module {
   type List<T> = Types.Pure.List<T>;
 
   /// Double-ended queue data type.

test/Queue.test.mo

@@ -2,6 +2,7 @@ import Suite "mo:matchers/Suite";
 import T "mo:matchers/Testable";
 import M "mo:matchers/Matchers";
 import Queue "../src/Queue";
+import PureQueue "../src/pure/Queue";
 import Iter "../src/Iter";
 import Nat "../src/Nat";
 import Runtime "../src/Runtime";
@@ -388,6 +389,94 @@ run(
   )
 );
 
+run(
+  suite(
+    "pure queue conversions",
+    [
+      test(
+        "empty to pure",
+        do {
+          let queue = Queue.empty<Nat>();
+          let pureQueue = Queue.toPure(queue);
+          PureQueue.isEmpty(pureQueue)
+        },
+        M.equals(T.bool(true))
+      ),
+      test(
+        "empty from pure",
+        do {
+          let pureQueue = PureQueue.empty<Nat>();
+          let queue = Queue.fromPure<Nat>(pureQueue);
+          Queue.isEmpty(queue)
+        },
+        M.equals(T.bool(true))
+      ),
+      test(
+        "singleton to pure",
+        do {
+          let queue = Queue.singleton<Nat>(1);
+          let pureQueue = Queue.toPure(queue);
+          Iter.toArray(PureQueue.values(pureQueue))
+        },
+        M.equals(T.array(T.natTestable, [1]))
+      ),
+      test(
+        "singleton from pure",
+        do {
+          let pureQueue = PureQueue.pushBack(PureQueue.empty(), 1);
+          let queue = Queue.fromPure<Nat>(pureQueue);
+          Iter.toArray(Queue.values(queue))
+        },
+        M.equals(T.array(T.natTestable, [1]))
+      ),
+      test(
+        "multiple elements to pure",
+        do {
+          let queue = Queue.fromIter<Nat>([1, 2, 3].vals());
+          let pureQueue = Queue.toPure(queue);
+          Iter.toArray(PureQueue.values(pureQueue))
+        },
+        M.equals(T.array(T.natTestable, [1, 2, 3]))
+      ),
+      test(
+        "multiple elements from pure",
+        do {
+          var pureQueue = PureQueue.empty<Nat>();
+          pureQueue := PureQueue.pushBack(pureQueue, 1);
+          pureQueue := PureQueue.pushBack(pureQueue, 2);
+          pureQueue := PureQueue.pushBack(pureQueue, 3);
+          let queue = Queue.fromPure<Nat>(pureQueue);
+          Iter.toArray(Queue.values(queue))
+        },
+        M.equals(T.array(T.natTestable, [1, 2, 3]))
+      ),
+      test(
+        "round trip mutable to pure to mutable",
+        do {
+          let original = Queue.fromIter<Nat>([1, 2, 3].vals());
+          let pureQueue = Queue.toPure(original);
+          let roundTrip = Queue.fromPure<Nat>(pureQueue);
+          Iter.toArray(Queue.values(roundTrip))
+        },
+        M.equals(T.array(T.natTestable, [1, 2, 3]))
+      ),
+      test(
+        "round trip pure to mutable to pure",
+        do {
+          var original = PureQueue.empty<Nat>();
+          original := PureQueue.pushBack(original, 1);
+          original := PureQueue.pushBack(original, 2);
+          original := PureQueue.pushBack(original, 3);
+          let mutableQueue = Queue.fromPure<Nat>(original);
+          let roundTrip = Queue.toPure(mutableQueue);
+          Iter.toArray(PureQueue.values(roundTrip))
+        },
+        M.equals(T.array(T.natTestable, [1, 2, 3]))
+      )
+    ]
+  )
+);
+
 // TODO: Use PRNG in new base library
 class Random(seed : Nat) {
   var number = seed;

test/pure/Queue.test.mo

@@ -35,31 +35,16 @@ func iterateBackward<T>(queue : Queue.Queue<T>) : Iter.Iter<T> {
   }
 };
 
-func toText(queue : Queue.Queue<Nat>) : Text {
-  var text = "[";
-  var isFirst = true;
-  for (element in iterateForward(queue)) {
-    if (not isFirst) {
-      text #= ", "
-    } else {
-      isFirst := false
-    };
-    text #= debug_show (element)
-  };
-  text #= "]";
-  text
-};
-
 func frontToText(t : (Nat, Queue.Queue<Nat>)) : Text {
-  "(" # Nat.toText(t.0) # ", " # toText(t.1) # ")"
+  "(" # Nat.toText(t.0) # ", " # Queue.toText(t.1, Nat.toText) # ")"
 };
 
 func frontEqual(t1 : (Nat, Queue.Queue<Nat>), t2 : (Nat, Queue.Queue<Nat>)) : Bool {
   t1.0 == t2.0 and Queue.equal(t1.1, t2.1, Nat.equal)
 };
 
 func backToText(t : (Queue.Queue<Nat>, Nat)) : Text {
-  "(" # toText(t.0) # ", " # Nat.toText(t.1) # ")"
+  "(" # Queue.toText(t.0, Nat.toText) # ", " # Nat.toText(t.1) # ")"
 };
 
 func backEqual(t1 : (Queue.Queue<Nat>, Nat), t2 : (Queue.Queue<Nat>, Nat)) : Bool {

validation/api/api.lock.json

@@ -875,6 +875,7 @@
       "public func filterMap<T, U>(queue : Queue<T>, project : T -> ?U) : Queue<U>",
       "public func forEach<T>(queue : Queue<T>, operation : T -> ())",
       "public func fromIter<T>(iter : Iter.Iter<T>) : Queue<T>",
+      "public func fromPure<T>(pureQueue : PureQueue.Queue<T>) : Queue<T>",
       "public func isEmpty<T>(queue : Queue<T>) : Bool",
       "public func map<T, U>(queue : Queue<T>, project : T -> U) : Queue<U>",
       "public func peekBack<T>(queue : Queue<T>) : ?T",
@@ -886,6 +887,7 @@
       "public type Queue<T>",
       "public func singleton<T>(element : T) : Queue<T>",
       "public func size<T>(queue : Queue<T>) : Nat",
+      "public func toPure<T>(queue : Queue<T>) : PureQueue.Queue<T>",
       "public func toText<T>(queue : Queue<T>, format : T -> Text) : Text",
       "public func values<T>(queue : Queue<T>) : Iter.Iter<T>"
     ]