content: -- arithmetic_mean :: [Number] -> Number
  on arithmetic_mean(xs)
  
      -- sum :: Number -> Number -> Number
      script sum
          on |λ|(accumulator, x)
              accumulator + x
          end |λ|
      end script
  
      foldl(sum, 0, xs) / (length of xs)
  end arithmetic_mean
  
  -- geometric_mean :: [Number] -> Number
  on geometric_mean(xs)
  
      -- product :: Number -> Number -> Number
      script product
          on |λ|(accumulator, x)
              accumulator * x
          end |λ|
      end script
  
      foldl(product, 1, xs) ^ (1 / (length of xs))
  end geometric_mean
  
  -- harmonic_mean :: [Number] -> Number
  on harmonic_mean(xs)
  
      -- addInverse :: Number -> Number -> Number
      script addInverse
          on |λ|(accumulator, x)
              accumulator + (1 / x)
          end |λ|
      end script
  
      (length of xs) / (foldl(addInverse, 0, xs))
  end harmonic_mean
  
  -- TEST -----------------------------------------------------------------------
  on run
      set {A, G, H} to ap({arithmetic_mean, geometric_mean, harmonic_mean}, ¬
          {{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}})
  
      {values:{arithmetic:A, geometric:G, harmonic:H}, inequalities:¬
          {|A >= G|:A ≥ G}, |G >= H|:G ≥ H}
  end run
  
  
  -- GENERIC FUNCTIONS ----------------------------------------------------------
  
  -- A list of functions applied to a list of arguments
  -- (<*> | ap) :: [(a -> b)] -> [a] -> [b]
  on ap(fs, xs)
      set {nf, nx} to {length of fs, length of xs}
      set acc to {}
      repeat with i from 1 to nf
          tell mReturn(item i of fs)
              repeat with j from 1 to nx
                  set end of acc to |λ|(contents of (item j of xs))
              end repeat
          end tell
      end repeat
      return acc
  end ap
  
  -- 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
  
  -- 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
  
  -- 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
  