Update iterator for next Gleam

2 files changed, 76 insertions, 78 deletions

diff --git a/src/gleam/iterator.gleam b/src/gleam/iterator.gleam
index c139140..8a4410d 100644
--- a/src/gleam/iterator.gleam
+++ b/src/gleam/iterator.gleam
@@ -1,7 +1,6 @@
 import gleam/list
 
 // Internal private representation of an Iterator
-
 type Action(element) {
   // Improper dancing in the middle of the street
   // Improper dancing in the middle of the street
@@ -9,33 +8,25 @@ type Action(element) {
   // Somebody better notify the chief of police
   Stop
   Continue(element, fn() -> Action(element))
-  // Yes!
 }
 
+// Yes!
 // Wrapper to hide the internal representation
-
-pub external type Iterator(element);
-
-// TODO: remove once we have opaque type wrappers
-external fn opaque(fn() -> Action(element)) -> Iterator(element)
-  = "gleam@iterator" "identity"
-
-external fn unopaque(Iterator(element)) -> fn() -> Action(element)
-  = "gleam@iterator" "identity"
+pub opaque type Iterator(element) {
+  Iterator(thunk: fn() -> Action(element))
+}
 
 pub fn identity(x) {
   x
 }
 
 // Public API for iteration
-
 pub type Step(element, acc) {
   Next(element, acc)
   Done
 }
 
 // Creating Iterators
-
 fn do_unfold(initial, f) {
   fn() {
     case f(initial) {
@@ -46,10 +37,13 @@ fn do_unfold(initial, f) {
 }
 
 // TODO: document
-pub fn unfold(from initial: acc, with f: fn(acc) -> Step(element, acc)) -> Iterator(element) {
+pub fn unfold(
+  from initial: acc,
+  with f: fn(acc) -> Step(element, acc),
+) -> Iterator(element) {
   initial
-  |> do_unfold(_, f)
-  |> opaque
+  |> do_unfold(f)
+  |> Iterator
 }
 
 // TODO: test
@@ -65,16 +59,18 @@ pub fn repeat(x: element) -> Iterator(element) {
 
 // TODO: document
 pub fn from_list(list: List(element)) -> Iterator(element) {
-  unfold(list, fn(acc) {
-    case acc {
-      [] -> Done
-      [head | tail] -> Next(head, tail)
-    }
-  })
+  unfold(
+    list,
+    fn(acc) {
+      case acc {
+        [] -> Done
+        [head, ..tail] -> Next(head, tail)
+      }
+    },
+  )
 }
 
 // Consuming Iterators
-
 fn do_fold(iterator, initial, f) {
   case iterator() {
     Continue(element, iterator) -> do_fold(iterator, f(element, initial), f)
@@ -83,10 +79,13 @@ fn do_fold(iterator, initial, f) {
 }
 
 // TODO: document
-pub fn fold(over iterator: Iterator(e), from initial: acc, with f: fn(e, acc) -> acc) -> acc {
-  iterator
-  |> unopaque
-  |> do_fold(_, initial, f)
+pub fn fold(
+  over iterator: Iterator(e),
+  from initial: acc,
+  with f: fn(e, acc) -> acc,
+) -> acc {
+  iterator.thunk
+  |> do_fold(initial, f)
 }
 
 // TODO: test
@@ -99,14 +98,17 @@ pub fn run(iterator) -> Nil {
 // TODO: document
 pub fn to_list(iterator: Iterator(element)) -> List(element) {
   iterator
-  |> fold(_, [], fn(e, acc) { [e | acc] })
+  |> fold([], fn(e, acc) { [e, ..acc] })
   |> list.reverse
 }
 
 fn do_take(iterator, desired, acc) {
   case desired > 0 {
     True -> case iterator() {
-      Continue(element, iterator) -> do_take(iterator, desired - 1, [element | acc])
+      Continue(
+        element,
+        iterator,
+      ) -> do_take(iterator, desired - 1, [element, ..acc])
       Stop -> acc
     }
     False -> acc
@@ -115,9 +117,8 @@ fn do_take(iterator, desired, acc) {
 
 // TODO: document
 pub fn take(from iterator: Iterator(e), up_to desired: Int) -> List(e) {
-  iterator
-  |> unopaque
-  |> do_take(_, desired, [])
+  iterator.thunk
+  |> do_take(desired, [])
   |> list.reverse
 }
 
@@ -133,14 +134,12 @@ fn do_drop(iterator, desired) {
 
 // TODO: document
 pub fn drop(from iterator: Iterator(e), up_to desired: Int) -> Iterator(e) {
-  iterator
-  |> unopaque
-  |> do_drop(_, desired)
-  |> opaque
+  iterator.thunk
+  |> do_drop(desired)
+  |> Iterator
 }
 
 // Transforming Iterators
-
 fn do_map(iterator, f) {
   fn() {
     case iterator() {
@@ -152,10 +151,9 @@ fn do_map(iterator, f) {
 
 // TODO: document
 pub fn map(over iterator: Iterator(a), with f: fn(a) -> b) -> Iterator(b) {
-  iterator
-  |> unopaque
-  |> do_map(_, f)
-  |> opaque
+  iterator.thunk
+  |> do_map(f)
+  |> Iterator
 }
 
 fn do_filter(iterator, predicate) {
@@ -171,11 +169,13 @@ fn do_filter(iterator, predicate) {
 }
 
 // TODO: document
-pub fn filter(iterator: Iterator(a), for predicate: fn(a) -> Bool) -> Iterator(a) {
-  iterator
-  |> unopaque
-  |> do_filter(_, predicate)
-  |> opaque
+pub fn filter(
+  iterator: Iterator(a),
+  for predicate: fn(a) -> Bool,
+) -> Iterator(a) {
+  iterator.thunk
+  |> do_filter(predicate)
+  |> Iterator
 }
 
 fn do_cycle(next: fn() -> Action(a), reset: fn() -> Action(a)) {
@@ -189,10 +189,9 @@ fn do_cycle(next: fn() -> Action(a), reset: fn() -> Action(a)) {
 
 // TODO: document
 pub fn cycle(iterator: Iterator(a)) -> Iterator(a) {
-  let iterator = iterator |> unopaque
-  iterator
-  |> do_cycle(_, iterator)
-  |> opaque
+  iterator.thunk
+  |> do_cycle(iterator.thunk)
+  |> Iterator
 }
 
 fn do_range(current, limit, inc) -> fn() -> Action(Int) {
@@ -209,5 +208,5 @@ pub fn range(from start, to stop) -> Iterator(Int) {
     False -> -1
   }
   |> do_range(start, stop, _)
-  |> opaque
+  |> Iterator
 }
diff --git a/test/gleam/iterator_test.gleam b/test/gleam/iterator_test.gleam
index 936621e..ec1eac3 100644
--- a/test/gleam/iterator_test.gleam
+++ b/test/gleam/iterator_test.gleam
@@ -1,16 +1,15 @@
-import gleam/expect
+import gleam/should
 import gleam/iterator
 import gleam/list
 
 // TODO: Property tests
-
 // a |> from_list |> to_list == a
 pub fn to_from_list_test() {
   let test = fn(subject) {
     subject
     |> iterator.from_list
     |> iterator.to_list
-    |> expect.equal(_, subject)
+    |> should.equal(subject)
   }
 
   test([])
@@ -19,13 +18,13 @@ pub fn to_from_list_test() {
   test([1, 2, 4, 8])
 }
 
-// a |> from_list |> take(_, n) == a |> list.take(_, n)
+// a |> from_list |> take(n) == a |> list.take(_, n)
 pub fn take_test() {
   let test = fn(n, subject) {
     subject
     |> iterator.from_list
-    |> iterator.take(_, n)
-    |> expect.equal(_, list.take(subject, n))
+    |> iterator.take(n)
+    |> should.equal(list.take(subject, n))
   }
 
   test(0, [])
@@ -40,30 +39,30 @@ pub fn take_test() {
   test(22, [0, 1, 2, 3, 4])
 }
 
-// a |> from_list |> fold(_, a, f) == a |> list.fold(_, a, f)
+// a |> from_list |> fold(a, f) == a |> list.fold(_, a, f)
 pub fn fold_test() {
   let test = fn(subject, acc, f) {
     subject
     |> iterator.from_list
-    |> iterator.fold(_, acc, f)
-    |> expect.equal(_, list.fold(subject, acc, f))
+    |> iterator.fold(acc, f)
+    |> should.equal(list.fold(subject, acc, f))
   }
 
-  let f = fn(e, acc) { [e | acc] }
+  let f = fn(e, acc) { [e, ..acc] }
   test([], [], f)
   test([1], [], f)
   test([1, 2, 3], [], f)
   test([1, 2, 3, 4, 5, 6, 7, 8], [], f)
 }
 
-// a |> from_list |> map(_, f) |> to_list == a |> list.map(_, f)
+// a |> from_list |> map(f) |> to_list == a |> list.map(_, f)
 pub fn map_test() {
   let test = fn(subject, f) {
     subject
     |> iterator.from_list
-    |> iterator.map(_, f)
+    |> iterator.map(f)
     |> iterator.to_list
-    |> expect.equal(_, list.map(subject, f))
+    |> should.equal(list.map(subject, f))
   }
 
   let f = fn(e) { e * 2 }
@@ -73,14 +72,14 @@ pub fn map_test() {
   test([1, 2, 3, 4, 5, 6, 7, 8], f)
 }
 
-// a |> from_list |> filter(_, f) |> to_list == a |> list.filter(_, f)
+// a |> from_list |> filter(f) |> to_list == a |> list.filter(_, f)
 pub fn filter_test() {
   let test = fn(subject, f) {
     subject
     |> iterator.from_list
-    |> iterator.filter(_, f)
+    |> iterator.filter(f)
     |> iterator.to_list
-    |> expect.equal(_, list.filter(subject, f))
+    |> should.equal(list.filter(subject, f))
   }
 
   let even = fn(x) { x % 2 == 0 }
@@ -96,33 +95,33 @@ pub fn filter_test() {
 pub fn repeat_test() {
   1
   |> iterator.repeat
-  |> iterator.take(_, 5)
-  |> expect.equal(_, [1, 1, 1, 1, 1])
+  |> iterator.take(5)
+  |> should.equal([1, 1, 1, 1, 1])
 }
 
 pub fn cycle_test() {
   [1, 2, 3]
   |> iterator.from_list
   |> iterator.cycle
-  |> iterator.take(_, 9)
-  |> expect.equal(_, [1, 2, 3, 1, 2, 3, 1, 2, 3])
+  |> iterator.take(9)
+  |> should.equal([1, 2, 3, 1, 2, 3, 1, 2, 3])
 }
 
 pub fn unfold_test() {
   iterator.unfold(2, fn(acc) { iterator.Next(acc, acc * 2) })
-  |> iterator.take(_, 5)
-  |> expect.equal(_, [2, 4, 8, 16, 32])
+  |> iterator.take(5)
+  |> should.equal([2, 4, 8, 16, 32])
 
   iterator.unfold(2, fn(_) { iterator.Done })
-  |> iterator.take(_, 5)
-  |> expect.equal(_, [])
+  |> iterator.take(5)
+  |> should.equal([])
 }
 
 pub fn range_test() {
   let test = fn(a, b, expected) {
     iterator.range(a, b)
     |> iterator.to_list
-    |> expect.equal(_, expected)
+    |> should.equal(expected)
   }
 
   test(0, 0, [])
@@ -135,7 +134,7 @@ pub fn range_test() {
 
 pub fn drop_test() {
   iterator.range(0, 10)
-  |> iterator.drop(_, 5)
+  |> iterator.drop(5)
   |> iterator.to_list
-  |> expect.equal(_, [5, 6, 7, 8, 9])
+  |> should.equal([5, 6, 7, 8, 9])
 }