Functional

Hush provides first class higher order functions, which is the fundamental building block for functional programming. As such, the paradigm integrates very well with the language, and it is recommend as the main approach for solving problems in Hush.

Here’s an example of a simple iterator library, using functional programming and implementing basic laziness:

  1. # Iterator: traversal utilities.
  3. # Construct an iterator.
  4. # An Iterator is an object capable of successively yielding values.
  5. # Iterators are *mutable* (they may mutate their inner state as they iterate).
  6. # Parameters:
  7. # * next: function() -> @[ finished: bool, value: any ] # the iterator function
  8. # Returns the Iterator instance.
  9. function Iterator(next)
  10.     @[
  11.         # Provide the next method.
  12.         next: next,
  14.         # Get the iterator function.
  15.         # Iterating mutates the iterator, which will successively yield the next value.
  16.         # This should be used in for loops, as in:
  17.         # for item in iterator.iter() do
  18.         #     ...
  19.         # end
  20.         iter: function ()
  21.             self.next
  22.         end,
  24.         # Get the nth element in the iterator.
  25.         # This is equivalent to calling self.next() `n + 1` times,
  26.         # but might be optimized for some iterators.
  27.         # Parameters:
  28.         # * n: the desired element index
  29.         # Returns the nth element.
  30.         nth: function (n)
  31.             for _ in std.range(0, n, 1) do
  32.                 let iteration = self.next()
  34.                 if iteration.finished then
  35.                     return iteration
  36.                 end
  37.             end
  39.             self.next()
  40.         end,
  42.         # Map a function over an iterator.
  43.         # This function is lazy.
  44.         # Parameters:
  45.         # * fun: function(any) -> any # the function to apply
  46.         # Returns a new iterator, consuming self.
  47.         map: function (fun)
  48.             let map = function (iteration)
  49.                 if iteration.finished then
  50.                     iteration
  51.                 else
  52.                     @[ finished: false, value: fun(iteration.value) ]
  53.                 end
  54.             end
  56.             let base = self
  58.             let it = Iterator(
  59.                 function ()
  60.                     map(base.next())
  61.                 end
  62.             )
  64.             # Elide mapping unnecessary elements when jumping.
  65.             # This is an important optimization for, e.g.:
  66.             # Array([1,2,3,4,5])
  67.             #     .map(fun)
  68.             #     .skip(3)
  69.             #     .collect()
  70.             it.nth = function (n)
  71.                 map(base.nth(n))
  72.             end
  74.             it
  75.         end,
  77.         # Filter the iterator by the given predicate.
  78.         # This function is lazy.
  79.         # Items for which the predicate returns true are kept.
  80.         # Parameters:
  81.         # * pred: function(any) -> bool # the predicate
  82.         # Returns a new iterator, consuming self.
  83.         filter: function (pred)
  84.             let base = self
  86.             Iterator(
  87.                 function ()
  88.                     let iteration = base.next()
  90.                     while not (iteration.finished or pred(iteration.value)) do
  91.                         iteration = base.next()
  92.                     end
  94.                     iteration
  95.                 end
  96.             )
  97.         end,
  99.         # Skip elements from the iterator.
  100.         # Equivalent to calling `nth(size - 1)` on an iterator.
  101.         # Returns a new iterator, consuming self.
  102.         skip: function(size)
  103.             if size > 0 then
  104.                 self.nth(size - 1)
  105.             end
  106.             self
  107.         end,
  109.         # Iterate up to some elements.
  110.         # This function is lazy.
  111.         # The iterator that will stop after `size` elements.
  112.         # Parameters:
  113.         # * size: int # how many elements to keep
  114.         # Returns a new iterator, consuming self.
  115.         take: function (size)
  116.             let base = self
  118.             let it = Iterator(
  119.                 function ()
  120.                     if size == 0 then
  121.                         @[ finished: true ]
  122.                     else
  123.                         size = size - 1
  124.                         base.next()
  125.                     end
  126.                 end
  127.             )
  129.             it.nth = function(n)
  130.                 if n + 1 > size then
  131.                     size = 0
  132.                     @[ finished: true ]
  133.                 else
  134.                     size = size - n
  135.                     base.nth(n)
  136.                 end
  137.             end
  139.             it
  140.         end,
  142.         # Fold elements into a single value.
  143.         # Parameters:
  144.         # * merge: function(any, any) -> any # the function to merge elements
  145.         # * acc: any # the default argument for merge
  146.         # Returns the resulting any, consuming self.
  147.         fold: function (merge, acc)
  148.             for item in self.iter() do
  149.                 acc = merge(item, acc)
  150.             end
  152.             acc
  153.         end,
  155.         # Collect the iterator's items.
  156.         # Parameters:
  157.         # * target: nil, array or function(any) # where to collect
  158.         # If target is nil, the elements are collected into a new array.
  159.         # If target is an array, the elements are collected by pushing to it.
  160.         # If target is a function, the elements are collected by calling the function.
  161.         # Returns nil if target is a function, or the resulting array otherwise.
  162.         collect: function (target)
  163.             let result = []
  164.             let push
  166.             let type = std.type(target)
  167.             if type == "function" then
  168.                 result = nil
  169.                 push = target
  170.             else
  171.                 if type == "array" then
  172.                     result = target
  173.                 end
  174.                 push = function (item)
  175.                     std.push(result, item)
  176.                 end
  177.             end
  179.             for item in self.iter() do
  180.                 push(item)
  181.             end
  183.             result
  184.         end
  185.     ]
  186. end
  188. # Construct an iterator for the given array.
  189. # Returns the Iterator instance.
  190. function Array(array)
  191.     let ix = 0
  193.     # Don't use `std.iter` in order to be able to optimize `nth`.
  194.     let it = Iterator(
  195.         function ()
  196.             if ix >= std.len(array) then
  197.                 @[ finished: true ]
  198.             else
  199.                 let value = array[ix]
  200.                 ix = ix + 1
  201.                 @[ finished: false, value: value ]
  202.             end
  203.         end
  204.     )
  206.     # Override nth with a O(1) implementation:
  207.     it.nth = function (n)
  208.         ix = ix + n
  209.         return it.next()
  210.     end
  212.     return it
  213. end
  215. # Construct an iterator for the given table.
  216. # There is no guarantee of iteration order.
  217. # Returns the Iterator instance.
  218. function Dict(dict)
  219.     return Iterator(std.iter(dict))
  220. end
  222. # Construct an empty iterator.
  223. # Returns the Iterator instance.
  224. function Empty()
  225.     return Iterator(
  226.         function ()
  227.             return @[ finished: true ]
  228.         end
  229.     )
  230. end