content: -- floyd :: [Int] -> [Int]
  on floyd(xs)
      set n to succ(length of xs)
      if n < 2 then
          {1}
      else
          enumFromTo(succ(n * (pred(n)) div 2), n * (succ(n)) div 2)
      end if
  end floyd
  
  
  -- floydN :: Int -> [[Int]]
  on floydN(n)
      take(n, iterate(floyd, {1}))
  end floydN
  
  
  -- showFloyd :: [[Int]] -> String
  on showFloyd(xs)
      script
          on |λ|(ns)
              script
                  on |λ|(n)
                      justifyRight(4, space, n as string)
                  end |λ|
              end script
              concat(map(result, ns))
          end |λ|
      end script
      unlines(map(result, xs))
  end showFloyd
  
  
  -- TEST -------------------------------------------------------------
  on run
  
      showFloyd(floydN(5))
  
  end run
  
  
  -- GENERIC ABSTRACTIONS ---------------------------------------
  
  -- concat :: [[a]] -> [a]
  -- concat :: [String] -> String
  on concat(xs)
      set lng to length of xs
      if 0 < lng and string is class of (item 1 of xs) then
          set acc to ""
      else
          set acc to {}
      end if
      repeat with i from 1 to lng
          set acc to acc & item i of xs
      end repeat
      acc
  end concat
  
  -- enumFromTo :: Int -> Int -> [Int]
  on enumFromTo(m, n)
      if m ≤ n then
          set lst to {}
          repeat with i from m to n
              set end of lst to i
          end repeat
          return lst
      else
          return {}
      end if
  end enumFromTo
  
  -- iterate :: (a -> a) -> a -> Gen [a]
  on iterate(f, x)
      script
          property v : missing value
          property g : mReturn(f)'s |λ|
          on |λ|()
              if missing value is v then
                  set v to x
              else
                  set v to g(v)
              end if
              return v
          end |λ|
      end script
  end iterate
  
  
  -- justifyRight :: Int -> Char -> String -> String
  on justifyRight(n, cFiller, strText)
      if n > length of strText then
          text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
      else
          strText
      end if
  end justifyRight
  
  
  -- length :: [a] -> Int
  on |length|(xs)
      set c to class of xs
      if list is c or string is c then
          length of xs
      else
          (2 ^ 29 - 1) -- (maxInt - simple proxy for non-finite)
      end if
  end |length|
  
  -- 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
  
  -- min :: Ord a => a -> a -> a
  on min(x, y)
      if y < x then
          y
      else
          x
      end if
  end min
  
  -- Lift 2nd class handler function into 1st class script wrapper
  -- mReturn :: First-class m => (a -> b) -> m (a -> b)
  on mReturn(f)
      if class of f is script then
          f
      else
          script
              property |λ| : f
          end script
      end if
  end mReturn
  
  -- pred :: Int -> Int
  on pred(x)
      (-1) + x
  end pred
  
  -- Egyptian multiplication - progressively doubling a list, appending
  -- stages of doubling to an accumulator where needed for binary
  -- assembly of a target length
  -- replicate :: Int -> a -> [a]
  on replicate(n, a)
      set out to {}
      if n < 1 then return out
      set dbl to {a}
  
      repeat while (n > 1)
          if (n mod 2) > 0 then set out to out & dbl
          set n to (n div 2)
          set dbl to (dbl & dbl)
      end repeat
      return out & dbl
  end replicate
  
  -- succ :: Int -> Int
  on succ(x)
      1 + x
  end succ
  
  -- take :: Int -> [a] -> [a]
  -- take :: Int -> String -> String
  on take(n, xs)
      set c to class of xs
      if list is c then
          if 0 < n then
              items 1 thru min(n, length of xs) of xs
          else
              {}
          end if
      else if string is c then
          if 0 < n then
              text 1 thru min(n, length of xs) of xs
          else
              ""
          end if
      else if script is c then
          set ys to {}
          repeat with i from 1 to n
              set v to xs's |λ|()
              if missing value is v then
                  return ys
              else
                  set end of ys to v
              end if
          end repeat
          return ys
      else
          missing value
      end if
  end take
  
  -- unlines :: [String] -> String
  on unlines(xs)
      set {dlm, my text item delimiters} to ¬
          {my text item delimiters, linefeed}
      set str to xs as text
      set my text item delimiters to dlm
      str
  end unlines
  