README: document nit_env.sh

[nit.git] / lib / pipeline.nit

diff --git a/lib/pipeline.nit b/lib/pipeline.nit
index 055823f..d3428f0 100644 (file)
--- a/lib/pipeline.nit
+++ b/lib/pipeline.nit
@@ -14,9 +14,8 @@
 
 # Pipelined filters and operations on iterators.
 #
-# This module enhance `Iterator`s with some methods that enable a
-# pipeline-like programing that offers the manupulation of
-# collections trough connected filters with reasonable memory constraints.
+# This module enhances `Iterator` with some methods that enable a pipeline-like programing.
+# The processing of elements in a pipeline is done trough connected filters that are implemented with reasonable memory constraints.
 module pipeline
 
 redef interface Iterator[E]
@@ -35,7 +34,9 @@ redef interface Iterator[E]
 
        # Filter: sort with a given `comparator`.
        # Important: require O(n) memory.
-       fun sort_with(comparator: Comparator[E]): Iterator[E]
+       #
+       #     assert ["a", "c", "b"].iterator.sort_with(alpha_comparator).to_a  == ["a", "b", "c"]
+       fun sort_with(comparator: Comparator): Iterator[E]
        do
                var a = self.to_a
                comparator.sort(a)
@@ -79,7 +80,7 @@ redef interface Iterator[E]
 
        # Alternate each item with `e`.
        #
-       #    assert [1,2,3].iterator.alternate(0).to_a               ==  [1,0,2,0,3]
+       #     assert [1,2,3].iterator.alternate(0).to_a              ==  [1,0,2,0,3]
        fun alternate(e: E): Iterator[E]
        do
                return new PipeAlternate[E](self, e)
@@ -87,7 +88,7 @@ redef interface Iterator[E]
 
        # Filter: reject a given `item`.
        #
-       #    assert [1,1,2,1,3].iterator.skip(1).to_a                ==  [2,3]
+       #     assert [1,1,2,1,3].iterator.skip(1).to_a               ==  [2,3]
        fun skip(item: E): Iterator[E]
        do
                return new PipeSkip[E](self, item)
@@ -99,7 +100,7 @@ redef interface Iterator[E]
        #
        #     var i = [1,2,3,4,5].iterator
        #     assert i.head(2).to_a   == [1,2]
-       #     i.to_a                  == [3,4,5]
+       #     assert i.to_a           == [3,4,5]
        fun head(length: Int): Iterator[E]
        do
                return new PipeHead[E](self, length)
@@ -158,6 +159,45 @@ redef interface Iterator[E]
        end
 end
 
+# Wraps an iterator to skip nulls.
+#
+# ~~~nit
+# var i: Iterator[Int]
+#
+# i = new NullSkipper[Int]([null, 1, null, 2, null: nullable Int].iterator)
+# assert i.to_a == [1, 2]
+#
+# i = new NullSkipper[Int]([1, null, 2, 3: nullable Int].iterator)
+# assert i.to_a == [1, 2, 3]
+# ~~~
+class NullSkipper[E: Object]
+       super Iterator[E]
+
+       # The inner iterator.
+       var inner: Iterator[nullable E]
+
+       redef fun finish do inner.finish
+
+       redef fun is_ok do
+               skip_nulls
+               return inner.is_ok
+       end
+
+       redef fun item do
+               skip_nulls
+               return inner.item.as(E)
+       end
+
+       redef fun next do
+               inner.next
+               skip_nulls
+       end
+
+       private fun skip_nulls do
+               while inner.is_ok and inner.item == null do inner.next
+       end
+end
+
 # Interface that reify a function.
 # Concrete subclasses must implements the `apply` method.
 #
@@ -294,13 +334,7 @@ private class PipeSkip[E]
        var source: Iterator[E]
        var skip_item: E
 
-       init(source: Iterator[E], skip_item: E)
-       do
-               self.source = source
-               self.skip_item = skip_item
-
-               do_skip
-       end
+       init do do_skip
 
        fun do_skip
        do
@@ -345,10 +379,8 @@ private class PipeSkipTail[E]
 
        var lasts = new List[E]
 
-       init(source: Iterator[E], length: Int)
+       init
        do
-               self.source = source
-               self.length = length
                var lasts = self.lasts
                while source.is_ok and lasts.length < length do
                        lasts.push(source.item)
@@ -375,13 +407,7 @@ private class PipeSelect[E]
 
        var predicate: Function[E, Bool]
 
-       init(source: Iterator[E], predicate: Function[E, Bool])
-       do
-               self.source = source
-               self.predicate = predicate
-
-               do_skip
-       end
+       init do do_skip
 
        fun do_skip
        do