use traits for iteration

Author: p7g

bench/bf.cb

@@ -38,7 +38,7 @@ function parse(it) {
     let ops = arraylist::new();
     let c;
 
-    while ((c = it()) != iter::STOP) {
+    while ((c = iter::next(it)) != iter::STOP) {
         if (c == '+') {
             arraylist::push(ops, Op{type="inc", value=1});
         } else if (c == '-') {
@@ -83,6 +83,6 @@ let args = argv();
 if (array::length(args) != 1) {
     println("Usage: ./cbcvm bf.cb <program>");
 } else {
-    let it = array::iter(string::chars(fs::read_file(args[0])));
+    let it = iter::iter(fs::read_file(args[0]));
     run(tape_new(), parse(it));
 }

docs/stdlib.md

@@ -112,10 +112,6 @@ Find the index of the element for which `predicate` returns true. If there is no
 
 A collector for converting an iterator into an array.
 
-### function `iter(array)`
-
-Create an iterator from array `array`.
-
 ### function `length(array)`
 
 Get the length of array `array`.
@@ -184,10 +180,6 @@ Insert `value` at the front of `list`
 
 Get the length of the list.
 
-### function `iter(list)`
-
-Create an iterator over `list`.
-
 ### function `new()`
 
 Create a new, empty linked list.
@@ -393,9 +385,9 @@ Create an iterator that counts from 0 to `to`.
 
 Create an iterator that counts up from `n` indefinitely.
 
-### struct `collector`
+### trait `Collector`
 
-An struct defining the required functions to convert an iterator into an arbitrary collection.
+A trait for converting an iterator into an arbitrary collection.
 
 ### object `STOP`
 
@@ -476,10 +468,6 @@ Create an empty arraylist with default initial capacity.
 
 Create an empty arraylist with the given initial capacity.
 
-### function `iter(list)`
-
-Create an iterator over arraylist `list`.
-
 ### function `from_array(len, array)`
 
 Create a new arraylist from `array`. The `len` argument should be the length
@@ -518,10 +506,6 @@ Set the value of `key` in `list` to `value`.
 A collector for converting an iterator of
 entries into an assoclist.
 
-### function `iter(list)`
-
-Create an iterator over the entries of `list`.
-
 ### function `length`
 
 Check the number of items in the list.
@@ -534,10 +518,6 @@ Create an empty assoclist.
 
 A compact byte array type.
 
-### function `iter(bytes)`
-
-Create an iterator over `bytes`.
-
 ### object `collector`
 
 A collector for converting an iterator into byte array.
@@ -711,10 +691,6 @@ Parse `str` as an integer of base `base`. Currently only works for base 10.
 A collector to convert an iterator of characters
 or strings into a string.
 
-### function `iter(str)`
-
-Create an iterator over the characters in `str`.
-
 ### function `from_bytes(bytes)`
 
 Convert a byte array to a string.
@@ -884,10 +860,6 @@ Get an iterator over the keys in `map`.
 
 Return the number of values in `map`.
 
-### function `iter(map)`
-
-Get an iterator over the key-value pairs in `map`.
-
 ### function `entries(map)`
 
 Get an iterator over the key-value pairs in `map`.

lib/_arraylist_impl.cb

@@ -1,4 +1,5 @@
 import _array;
+import _iter_stop;
 
 export struct ArrayList {
   length,
@@ -87,6 +88,8 @@ export function foreach(self, func) {
   let array = self.array;
 
   for (let i = 0; i < len; i += 1) {
-    func(array[i], i, self);
+    if (func(array[i], i, self) == _iter_stop::STOP) {
+      break;
+    }
   }
 }

lib/_iter.cb

@@ -1,25 +1,62 @@
 import _array;
 import _arraylist_impl;
+import _iter_stop;
+import trait;
 
-export let STOP = struct {};
-export struct collector { init, reduce, finalize }
+export let STOP = _iter_stop::STOP;
 
-export function array_iter(array) {
-  let i = 0;
-  let len = _array::length(array);
-  return function array_iterator() {
-    if (i == len) {
+export let Iterable = trait::new("Iterable", [trait::method("iter")]);
+export let Iterator = trait::new("Iterator", [trait::method("next")]);
+export let Collector = trait::new("Collector", [
+  trait::method("init"),
+  trait::method("reduce"),
+  trait::method("finalize"),
+]);
+
+struct ArrayCollector {}
+export let array_collector = ArrayCollector {};
+
+trait::impl(Collector, ArrayCollector, struct {
+  function init(self) {
+    return _arraylist_impl::new();
+  }
+
+  function reduce(self, list, item) {
+    _arraylist_impl::push(list, item);
+    return list;
+  }
+
+  function finalize(self, list) {
+    return _arraylist_impl::to_array(list);
+  }
+});
+
+trait::impl(Iterable, trait::primitive("array"), struct {
+  function iter(self) {
+    return ArrayIterator {
+      i = 0,
+      len = _array::length(self),
+      array = self,
+    };
+  }
+});
+
+struct ArrayIterator { i, len, array }
+
+trait::impl(Iterable, ArrayIterator, struct {
+  function iter(self) {
+    return self;
+  }
+});
+
+trait::impl(Iterator, ArrayIterator, struct {
+  function next(self) {
+    if (self.i == self.len) {
       return STOP;
     }
 
-    let item = array[i];
-    i += 1;
+    let item = self.array[self.i];
+    self.i += 1;
     return item;
-  };
-}
-
-export let array_collector = collector {
-  init = _arraylist_impl::new,
-  reduce = _arraylist_impl::push,
-  finalize = _arraylist_impl::to_array,
-};
+  }
+});

lib/_iter_stop.cb

@@ -0,0 +1 @@
+export let STOP = struct {};

lib/array.cb

@@ -14,10 +14,6 @@ doc.add(
 export let length = _array::length;
 doc.add("function", "length(array)", "Get the length of array `array`.");
 
-export let iter = _iter::array_iter;
-
-doc.add("function", "iter(array)", "Create an iterator from array `array`.");
-
 export let collector = _iter::array_collector;
 
 doc.add("object", "collector", "A collector for converting an iterator into an array.");
@@ -58,7 +54,9 @@ export function foreach(self, func) {
   let len = length(self);
 
   for (let i = 0; i < len; i += 1) {
-    func(self[i], i, self);
+    if (func(self[i], i, self) == _iter::STOP) {
+      break;
+    }
   }
 }
 

lib/arraylist.cb

@@ -2,6 +2,7 @@ import _array;
 import _arraylist_impl;
 import docs;
 import iter;
+import trait;
 
 let doc = docs::module("arraylist", "A growable array.");
 
@@ -16,20 +17,30 @@ doc.add(
 of `array`.",
 );
 
-export function iter(self) {
-  let i = 0;
+trait::impl(iter::Iterable, ArrayList, struct {
+  function iter(self) {
+    return ArrayListIterator { list = self, i = 0 };
+  }
+});
+
+struct ArrayListIterator { list, i }
+
+trait::impl(iter::Iterable, ArrayListIterator, struct {
+  function iter(self) {
+    return self;
+  }
+});
 
-  return function arraylist_iterator() {
-    if (i >= self.length) {
+trait::impl(iter::Iterator, ArrayListIterator, struct {
+  function next(self) {
+    if (self.i >= self.list.length) {
       return iter::STOP;
     }
-    let val = get(self, i);
-    i += 1;
+    let val = get(self.list, self.i);
+    self.i += 1;
     return val;
-  };
-}
-
-doc.add("function", "iter(list)", "Create an iterator over arraylist `list`.");
+  }
+});
 
 export let with_capacity = _arraylist_impl::with_capacity;
 
@@ -84,11 +95,23 @@ doc.add(
   "Push `value` on to the end of `list`, growing it if necessary.",
 );
 
-export let collector = iter::collector {
-  init = new,
-  reduce = push,
-  finalize = function (list) { return list; },
-};
+struct ArrayListCollector {}
+export let collector = ArrayListCollector {};
+
+trait::impl(iter::Collector, ArrayListCollector, struct {
+  function init(self) {
+    return new();
+  }
+
+  function reduce(self, list, value) {
+    push(list, value);
+    return list;
+  }
+
+  function finalize(self, list) {
+    return list;
+  }
+});
 
 doc.add("object", "collector", "A collector for converting an iterator into an arraylist.");
 

lib/assoclist.cb

@@ -1,6 +1,7 @@
 import arraylist;
 import docs;
 import iter;
+import trait;
 
 let doc = docs::module(
   "assoclist",
@@ -19,18 +20,23 @@ function get_entry(self, key) {
   });
 }
 
-export let iter = arraylist::iter;
+struct AssocListCollector {}
+export let collector = AssocListCollector {};
 
-doc.add("function", "iter(list)", "Create an iterator over the entries of `list`.");
+trait::impl(iter::Collector, AssocListCollector, struct {
+  function init(self) {
+    return new();
+  }
 
-export let collector = iter::collector {
-  init = new,
-  reduce = function (list, [key, value]) {
+  function reduce(self, list, [key, value]) {
     set(list, key, value);
     return list;
-  },
-  finalize = function (list) { return list; },
-};
+  }
+
+  function finalize(self, list) {
+    return list;
+  }
+});
 
 doc.add("object", "collector", "A collector for converting an iterator of
 entries into an assoclist.");
@@ -107,4 +113,4 @@ export function entries(self) {
   return arraylist::to_array(self);
 }
 
-doc.add("function", "entries(list)", "Get all entries from `list`.");
+doc.add("function", "entries(list)", "Get all entries from `list`.");

lib/base64.cb

@@ -31,7 +31,7 @@ export function decode_size(payload) {
     let len = string::length(payload);
     let npadding = 0;
     # FIXME: not ideal
-    iter::foreach(string::iter(payload), function (c) {
+    iter::foreach(payload, function (c) {
         if (c == '=') {
             npadding += 1;
         }