Added iterables.

Vexatos · Vexatos · commit fd43bdc2699f · 2018-04-10T21:41:13.000+02:00
diff --git a/README.md b/README.md
@@ -14,6 +14,7 @@ This is a Lua library I made for more convenient functional programming. It prov
         - [Inserting values into lists](#inserting-values-into-lists)
         - [String iterators](#string-iterators)
       - [Utility functions for wrapped tables](#utility-functions-for-wrapped-tables)
+    - [Iterables](#iterables)
     - [Lambdas](#lambdas)
       - [Conditional lambda functions](#conditional-lambda-functions)
       - [Utility functions for wrapped and normal functions](#utility-functions-for-wrapped-and-normal-functions)
@@ -152,6 +153,37 @@ end
  - `lpairs(t:wrapped table)` This functions works just like `ipairs` when called with a list or wrapped string and just like `pairs` when called with anything else.
  - `isList(t:wrapped table or table):boolean` This function returns true if the table is either a list (as a wrapped table) or a normal table that can be turned into a list (i.e. if every key in the table is a number valid for `ipairs`)
 
+### Iterables
+Iterables are objects that wrap a function to iterate over: The only parameter they take is a function that takes the current iteration index (or no parameter) and returns a value each time it is called, and nil when there is no new value left to return. Most of the [methods that can be called on wrapped tables](#wrapped-tables-1) can also be called on iterables.
+
+```lua
+local function supply(index)
+  if index <= 10 then
+    return index * index
+  end
+end
+
+local itr = $(supply) -- Initializing an iterable for an existing function.
+
+for i, j in pairs(itr) do -- This calls the function until it returns nil, starting with an iteration index of 1, and provides the iteration index and value.
+  print(i, j)             -- In this case, the first ten squares of natural numbers are printed.
+end
+
+local itr2 = $(i -> i <= 10 and i*i or nil) -- Iterables can also be initialized using lambda functions.
+
+for val in itr2 do -- This iterates through the iterable, only providing the value.
+  print(val)
+end
+
+local itr3 = $( -> switch(math.random(0, 9),
+  (val! val >= 3 -> val)
+)) -- Of course, the supplier function does not have to use the index parameter.
+
+for i, j <- itr3 do -- Selene's for loop syntax works as well.
+  print(val)
+end
+```
+
 ### Lambdas
 Lambdas are wrapped in `()` brackets and always look like `(<var1> [, var2, ...] -> <operation>)`. Alternatively to the `->` you can also use `=>`.
 ```lua
@@ -265,7 +297,7 @@ These functions will not work directly called on a string, i.e. `string.drop("He
  - `string.iter(s:string)` This functions returns an iterator over the string `s`, so you can iterate through the characters of the string using `for index, char in string.iter(s) do ... end`.
 
 ### Wrapped tables
-These are the functions you can call on wrapped tables. `$()` represents a wrapped list or map, `$l()` represents a list.
+These are the functions you can call on wrapped tables. `$()` represents a wrapped list or map, `$l()` represents a list, `$i()` represents an iterable.
  - `$():concat(sep:string, i:number, j:number):string` This works exactly like `table.concat`.
  - `$():foreach(f:function)` This works exactly like `string.foreach`, just that it will iterate through each key/value pair in the table.
  - `$():map(f:function):list or map` This works exactly like `string.map`, just that it will iterate through each key/value pair in the table.
@@ -302,6 +334,7 @@ These are the functions you can call on wrapped tables. `$()` represents a wrapp
  - `$l():reverse():list` This function will invert the list so that the last entry will be the first one etc.
  - `$l():flatten():list` This works exactly like `table.flatten`.
  - `$l():zip(other:list or table or function):list` This will merge the other table (which has to be an ipairs-valid list) or list into itself if both lists have the same length, in the pattern `{{t1[1], t2[1]}, {t1[2], t2[2]}, ...}`. If `other` is a function or wrapped function, it will call it once per iteration and merge the returned value in the described pattern.
+ - `$i():collect():list` This function will iterate through the iterable and add every returned element to a list which it will return.
 
 ### Wrapped strings
 Wrapped strings or stringslists can mostly be seen as lists and have most of the functions wrapped tables have (including `drop`, `dropwhile` and `reverse`).
diff --git a/selene/lib/selene/init.lua b/selene/lib/selene/init.lua
@@ -132,25 +132,26 @@ local function lpairs(obj)
 end
 
 local allMaps = { "map", "list", "stringlist" }
+local allIterables = { "map", "list", "stringlist", "iterable" }
+local allIndexables = {"list", "stringlist", "iterable"}
 
 -- Errors if the value is not a valid type (list or map)
 local function checkType(n, have, ...)
   have = tblType(have)
   local things = { ... }
-  if #things == 0 then things = allMaps end
-  local function check(want, ...)
-    if not want then
-      return false
-    else
-      return have == want or check(...)
+  if #things == 0 then
+    things = allIterables
+  elseif #things == 1 and type(things[1]) == "table" then
+    things = things[1]
+  end
+  for _, want in ipairs(things) do
+    if have == want then
+      return
     end
   end
-
-  if not check(table.unpack(things)) then
-    local msg = string.format("[Selene] bad argument #%d (%s expected, got %s)",
-      n, table.concat({ ... }, " or "), have)
-    error(msg, 3)
-  end
+  local msg = string.format("[Selene] bad argument #%d (%s expected, got %s)",
+    n, table.concat(things, " or "), have)
+  error(msg, 3)
 end
 
 -- Errors if the value is not a function or does not have the required parameter count
@@ -271,6 +272,7 @@ local fmt = {
 
 local _Table = {}
 local _String = {}
+local _Iterable = {}
 
 local smt = shallowcopy(mt)
 smt.ltype = "stringlist"
@@ -279,6 +281,42 @@ smt.__call = function(str)
 end
 smt.__tostring = smt.__call
 
+local function inext(spl, i)
+  local v = spl(i)
+  if v == nil then
+    return v
+  else
+    return i+1, v
+  end
+end
+
+local imt = {
+  __call = function(itr)
+    local v = itr._spl(itr._i)
+    itr._i = itr._i + 1
+    return v
+  end,
+  __len = function(itr)
+    error("[Selene] attempt to get length of " .. tblType(itr), 2)
+  end,
+  __pairs = function(itr)
+    return inext, itr._spl, 1
+  end,
+  __ipairs = function(itr)
+    return inext, itr._spl, 1
+  end,
+  __tostring = function(itr)
+    return tostring(itr._spl)
+  end,
+  __index = function(itr, key)
+    error("[Selene] attempt to index " .. tblType(itr), 2)
+  end,
+  __newindex = function(itr, key, val)
+    error("[Selene] attempt to insert value into " .. tblType(itr), 2)
+  end,
+  ltype = "iterable"
+}
+
 --------
 -- Initialization functions
 --------
@@ -365,11 +403,25 @@ local function newFunc(f, parCnt, applies)
   return newF
 end
 
-local function newWrappedTable(...)
+local function newIterable(spl)
+  checkType(1, spl, "function")
+  local newI = {}
+  newI._spl = spl
+  newI._i = 1
+  for i, j in pairs(_Iterable) do
+    newI[i] = j
+  end
+  setmetatable(newI, imt)
+  return newI
+end
+
+local function newGeneric(...)
   local t = ...
   if #{ ... } > 1 then t = { ... } end
   if type(t) == "string" then
     return newString(t)
+  elseif tblType(t) == "function" then
+    return newIterable(t)
   else
     return newListOrMap(t)
   end
@@ -685,14 +737,17 @@ local function tbl_foldright(self, start, f)
 end
 
 local function tbl_reduceleft(self, f)
-  checkType(1, self, "list", "stringlist")
+  checkType(1, self, "list", "stringlist", "iterable")
   checkFunc(2, f)
-  if #self <= 0 then
-    error("[Selene] bad argument #1 (got empty list)", 2)
-  end
-  local m = self[1]
-  for i = 2, #self do
-    m = f(m, self._tbl[i])
+  local d = false
+  local m
+  for i, j in mpairs(self) do
+    if d then
+      m = f(m, j)
+    else
+      d = true
+      m = j
+    end
   end
   return m
 end
@@ -714,7 +769,7 @@ local function tbl_find(self, f)
 end
 
 local function tbl_index(self, f)
-  checkType(1, self, "list", "stringlist")
+  checkType(1, self, allIndexables)
   checkFunc(2, f)
   local parCnt = checkParCnt(parCount(f, 2))
   for i, j in mpairs(self) do
@@ -742,7 +797,7 @@ local function rawflatten(self)
 end
 
 local function tbl_flatten(self)
-  checkType(1, self, "list")
+  checkType(1, self, "list", "iterable")
   return newListOrMap(rawflatten(self._tbl))
 end
 
@@ -801,7 +856,7 @@ local function tbl_contains(self, val)
 end
 
 local function tbl_containskey(self, key)
-  checkType(1, self)
+  checkType(1, self, allMaps)
   return self._tbl[key] ~= nil
 end
 
@@ -859,7 +914,7 @@ local function rawvalues(self)
 end
 
 local function tbl_clear(self)
-  checkType(1, self)
+  checkType(1, self, allMaps)
   for _, j in ipairs(rawkeys(self)) do
     self._tbl[j] = nil
   end
@@ -876,6 +931,16 @@ local function tbl_values(self)
   return newList(rawvalues(self))
 end
 
+-- for iterable objects
+
+local function itr_collect(self)
+  local collected = {}
+  for i, j in mpairs(self) do
+    insert(collected, false, i, j)
+  end
+  return newListOrMap(collected)
+end
+
 -- for the actual table library
 
 local function tbl_range(start, stop, step)
@@ -904,12 +969,12 @@ local function tbl_zipped(one, two)
 end
 
 local function tbl_call(self, f, ...)
-  checkType(1, self)
+  checkType(1, self, allMaps)
   checkFunc(2, f)
   local res = f(self._tbl, ...)
   local tRes = tblType(res)
   if tRes == "table" or tRes == "string" then
-    return newWrappedTable(res)
+    return newGeneric(res)
   else
     return res
   end
@@ -991,7 +1056,7 @@ local function str_foreach(self, f)
   checkFunc(2, f)
   local parCnt = checkParCnt(parCount(f))
   for i = 1, #self do
-    f(parCnt(i, j))
+    f(parCnt(i, self:sub(i,i)))
   end
 end
 
@@ -1340,15 +1405,18 @@ local function loadSeleneConstructs()
   _Table.values = tbl_values
 
   _Table.shallowcopy = function(self)
-    checkType(1, self)
+    checkType(1, self, allMaps)
     return newListOrMap(shallowcopy(self._tbl))
   end
 
   _Table.switch = function(self, ...)
-    checkType(1, self)
+    checkType(1, self, allMaps)
     return switch(self, ...)
   end
 
+  _Iterable = shallowcopy(_Table)
+  _Iterable.collect = itr_collect
+
   _String.foreach = tbl_foreach
   _String.map = tbl_map
   _String.flatmap = tbl_flatmap
@@ -1396,14 +1464,15 @@ local function loadSelene(env, lvMode)
     env._selene.liveMode = true
   end
 
-  env._selene._new = newWrappedTable
+  env._selene._new = newGeneric
   if not env.checkArg then
     env.checkArg = checkArg
     env._selene._checkArg = true
   end
   env._selene._newString = newString
   env._selene._newList = newList
   env._selene._newFunc = newFunc
+  env._selene._newIterable = newIterable
   env._selene._newOptional = newOptional
   env._selene._VERSION = VERSION
   env._selene._parse = parse
diff --git a/selene/lib/selene/parser.lua b/selene/lib/selene/parser.lua
@@ -322,6 +322,9 @@ local function findDollars(tokens, i, part, line)
   elseif curr:find("^o") then
     tokens[i][1] = "_selene._newOptional"
     table.remove(tokens, i + 1)
+  elseif curr:find("^i") then
+    tokens[i][1] = "_selene._newIterable"
+    table.remove(tokens, i + 1)
   else
     perror("invalid $ at index " .. i .. " (line " .. line .. ")")
   end
