content: on run
      -- PASSING FUNCTIONS AS ARGUMENTS TO
      -- MAP, FOLD/REDUCE, AND FILTER, ACROSS A LIST
  
      set lstRange to {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
  
      map(squared, lstRange)
      --> {0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100}
  
      foldl(summed, 0, map(squared, lstRange))
      --> 385
  
      filter(isEven, lstRange)
      --> {0, 2, 4, 6, 8, 10}
  
  
      -- OR MAPPING OVER A LIST OF FUNCTIONS
  
      map(testFunction, {doubled, squared, isEven})
  
      --> {{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20},
      --    {0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100},
      --    {true, false, true, false, true, false, true, false, true, false, true}}
  end run
  
  -- testFunction :: (a -> b) -> [b]
  on testFunction(f)
      map(f, {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10})
  end testFunction
  
  
  -- MAP, REDUCE, FILTER
  
  -- Returns a new list consisting of the results of applying the
  -- provided function to each element of the first list
  -- map :: (a -> b) -> [a] -> [b]
  on map(f, xs)
      tell mReturn(f)
          set lng to length of xs
          set lst to {}
          repeat with i from 1 to lng
              set end of lst to |λ|(item i of xs, i, xs)
          end repeat
          return lst
      end tell
  end map
  
  -- Applies a function against an accumulator and
  -- each list element (from left-to-right) to reduce it
  -- to a single return value
  
  -- In some languages, like JavaScript, this is called reduce()
  
  -- Arguments: function, initial value of accumulator, list
  -- foldl :: (a -> b -> a) -> a -> [b] -> a
  on foldl(f, startValue, xs)
      tell mReturn(f)
          set v to startValue
          set lng to length of xs
          repeat with i from 1 to lng
              set v to |λ|(v, item i of xs, i, xs)
          end repeat
          return v
      end tell
  end foldl
  
  
  -- Sublist of those elements for which the predicate
  -- function returns true
  -- filter :: (a -> Bool) -> [a] -> [a]
  on filter(f, xs)
      tell mReturn(f)
          set lst to {}
          set lng to length of xs
          repeat with i from 1 to lng
              set v to item i of xs
              if |λ|(v, i, xs) then set end of lst to v
          end repeat
          return lst
      end tell
  end filter
  
  -- Lift 2nd class handler function into 1st class script wrapper
  -- mReturn :: Handler -> Script
  on mReturn(f)
      if class of f is script then
          f
      else
          script
              property |λ| : f
          end script
      end if
  end mReturn
  
  -- HANDLER FUNCTIONS TO BE PASSED AS ARGUMENTS
  
  -- squared :: Number -> Number
  on squared(x)
      x * x
  end squared
  
  -- doubled :: Number -> Number
  on doubled(x)
      x * 2
  end doubled
  
  -- summed :: Number -> Number -> Number
  on summed(a, b)
      a + b
  end summed
  
  -- isEven :: Int -> Bool
  on isEven(x)
      x mod 2 = 0
  end isEven
  