feat(iter): add take, drop, slice funcs

Author: kollhof

src/iter.fnk

@@ -1,11 +1,10 @@
+{max_int} = import './num'
 
-# nth	☑	☐	☐	☑
-# slice	☐	☑	☑	☐
-
-# partition	☑	☑	☐	☑
-# product	☑	☑	☐	☐
-# compress	☐	☑	☑	☐
-# permutations	☐	☑	☑	☐
+# TODO add:
+# partition
+# product
+# compress
+# permutations
 
 repeat = unfold item:
   item
@@ -29,6 +28,16 @@ chain = fn ...iterables:
       ...iterable
 
 
+insert_at = fn idx, insert_items: fn items:
+  pipe items:
+    map item, curr=0:
+      all = match curr:
+        idx: chain insert_items, [item]
+        else: [item]
+
+      (...all, curr + 1)
+
+
 cycle = fn iterable:
   pipe [...iterable]:
     unfold items:
@@ -51,41 +60,64 @@ sort = fn compare: fn iterable:
   [...iterable].sort compare
 
 
-iterator = fn iterable:
-  iterable.(Symbol.iterator)()
+unique = fn iterable: new Set iterable
 
 
-unique = fn iterable: new Set iterable
 
+drop = fn num_items: fn items:
+  pipe items:
+    map item, idx=0: ([item, idx], idx + 1)
+    # TODO: should loxia add an accu to filter?
+    filter [, idx]: idx >= num_items
+    map [item]: item
 
-next = fn iter:
-  {done, value} = iter.next()
-  [value, done]
 
+take = fn num_items: fn items:
+  iter = items.(Symbol.iterator)()
+  pipe count 0:
+    while ctr: ctr < num_items
+    map _: iter.next()
+    while {done}: done == false
+    map {value}: value
 
-next_values = fn iters:
+
+slice = fn start, end=max_int: fn items:
+  match start:
+    ? + end < 0:
+      # TODO: use a sliding buffer while iterating over items
+      [...items].slice start, end
+
+    else:
+      pipe items:
+        drop start
+        take end - start
+
+
+_next_values = fn iters:
   pipe iters:
+    # TODO should we stop getting next item if any are done?
     map iter:
-      [value, done] = next iter
+      {value, done} = iter.next()
       ...match done:
         true: []
         else: [value]
 
 
 zip = fn ...iterables:
   [...iters] = pipe iterables:
-    map iterable: iterator iterable
+    map iterable: iterable.(Symbol.iterator)()
 
   {length: min_len} = iters
 
   pipe:
     unfold:
-      [...next_values iters]
+      [..._next_values iters]
 
     while {length}:
       length == min_len
 
 
+
 length = fn iterable:
   match iterable:
     {length: {}}: iterable.length

src/iter.test.fnk

@@ -2,7 +2,7 @@
 
 {
   repeat, count, enumerate, zip, cycle, chain, reverse, sort, unique, flatten
-  length, join, for_each
+  length, join, for_each, slice, insert_at, take, drop
 } = import './iter'
 
 {pad_start} = import './str'
@@ -68,6 +68,15 @@ describe 'iter - transforming funcs', fn:
         ['a', 'b', 'c', 1, 2, 3]
 
 
+  it 'inserts items into iterable', fn:
+    expect
+      pipe '123456':
+        insert_at 3, 'abc'
+        join ''
+      to_equal
+        '123abc456'
+
+
   it 'creates unique set of items', fn:
     expect
       pipe [1, 2, 2, 3]:
@@ -106,6 +115,68 @@ describe 'iter - transforming funcs', fn:
         ['1', '2', '11', '222']
 
 
+describe 'slice', fn:
+  it 'advances ignores n elements', fn:
+    expect
+      pipe '1234567890':
+        drop 5
+        join ''
+      to_equal '67890'
+
+
+  it 'filters n elements', fn:
+    expect
+      pipe '1234567890':
+        take 5
+        join ''
+      to_equal '12345'
+
+
+  it 'takes 0 length slice', fn:
+    expect
+      pipe count 0:
+        slice 1, 1
+        [...?]
+      to_equal
+        []
+
+
+  it 'takes regular slice', fn:
+    expect
+      pipe count 0:
+        slice 0, 3
+        [...?]
+      to_equal
+        [0, 1, 2]
+
+
+  it 'takes slice from start to end of iterable', fn:
+    expect
+      pipe '0123456789':
+        slice 5
+        [...?]
+      to_equal
+        [...'56789']
+
+
+  it 'takes end-offset slice', fn:
+    expect
+      pipe '0123456789':
+        slice 0, -5
+        [...?]
+      to_equal
+        [...'01234']
+
+    expect
+      pipe '0123456789':
+        # TODO remove parens
+        slice (-5, -1)
+        [...?]
+      to_equal
+        [...'5678']
+
+
+
 describe 'folding funcs', fn:
   it 'gets length', fn:
     expect