prelude 0.0.3 → 0.0.5

data/lib/prelude/functors.rb

@@ -0,0 +1,72 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+#
+# $Id: functors.rb 34 2007-10-23 21:38:09Z prelude $
+
+module Prelude
+
+  ID       = Lambda.new { |x|         x }
+  IDN      = Lambda.new { |*x|        x }
+  NEG      = Lambda.new { |x|     -   x }  
+  INC      = Lambda.new { |x|   x +   1 }
+  DEC      = Lambda.new { |x|   x -   1 }
+  PLUS     = Lambda.new { |x,y| x +   y }
+  MINUS    = Lambda.new { |x,y| x -   y }
+  MUL      = Lambda.new { |x,y| x *   y }
+  DIV      = Lambda.new { |x,y| x /   y }
+  MOD      = Lambda.new { |x,y| x %   y }
+  POWER    = Lambda.new { |x,y| x **  y }
+  NOT      = Lambda.new { |x,y|   !   x }
+  BOOL_AND = Lambda.new { |x,y| x &&  y }
+  BOOL_OR  = Lambda.new { |x,y| x ||  y }
+  XOR      = Lambda.new { |x,y| x ^   y }
+  BIT_AND  = Lambda.new { |x,y| x &   y }
+  BIG_OR   = Lambda.new { |x,y| x |   y }
+  MATCH    = Lambda.new { |x,y| x =~  y }
+  EQ       = Lambda.new { |x,y| x ==  y }
+  NE       = Lambda.new { |x,y| x !=  y }
+  LT       = Lambda.new { |x,y| x <   y }
+  GT       = Lambda.new { |x,y| x >   y }
+  LE       = Lambda.new { |x,y| x <=  y }
+  GE       = Lambda.new { |x,y| x >=  y } 
+  COMPARE  = Lambda.new { |x,y| x <=> y }
+  FST      = Lambda.new { |x,_| x       }
+  SND      = Lambda.new { |_,x| x       }
+  AT       = Lambda.new { |x,y| x[y]    } 
+
+  CALL     = Lambda.new { |x,y| x.call(y) }
+  FEED     = Lambda.new { |x,y| y.call(x) }
+  TO_A     = Lambda.new { |x|   x.to_a    }
+  TO_S     = Lambda.new { |x|   x.to_s    }
+  TO_I     = Lambda.new { |x|   x.to_i    }
+  TO_SYM   = Lambda.new { |x|   x.to_sym  }
+  TO_F     = Lambda.new { |x|   x.to_f    }
+
+
+  # Always returns the given value.
+  CONST = Lambda.new { |v| Lambda.new { |*list| v } }
+
+  # Returns the n-th argument
+  NTH = Lambda.new { |n| Lambda.new { |*list| list[n] } }
+
+end # Prelude

data/lib/prelude/lambda.rb

@@ -0,0 +1,89 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+module Prelude
+
+  # $Id: lambda.rb 34 2007-10-23 21:38:09Z prelude $
+  #
+  # Somewhat extended version of Ruby's native lambda/Proc that defines all needed methods. We
+  # probably can get away with modifying the Proc class, but this approach seems safer.
+  class Lambda < Proc
+    
+    def initialize(&block)
+      Proc.new(&block)
+    end
+    
+    alias proc_call call
+    def call(*args)
+      #p "call #{self.inspect} #{args.inspect} arity #{self.arity}"
+      proc_call(*args)
+    end
+    alias [] call
+
+    def *(right)
+      Lambda.new {|*a| 
+        #p "* #{self.inspect} #{right.inspect} #{a.inspect}"
+
+#         req = right.arity
+#         if req > 0
+#           right_args = a[0..req-1]
+#           left_args = a[req..-1]
+#         else
+#           right_args = a
+#           left_args = []
+#         end
+
+#         p "right_args #{right_args.inspect}"
+#         right_res = right[*right_args]
+
+#         p "right_res #{right_res.inspect}"
+#         if req > 0
+#           left_args = [right_res] + left_args
+#         else
+#           left_args = right_res
+#         end
+#         p "left_args #{left_args.inspect}"
+#         self[*left_args]
+
+        # Compact version of the above (delete the above when done!)
+        req = right.arity
+        if req > 0
+          self[*([right[*a[0..req-1]]] + a[req..-1]) ]
+        else
+          self[*right[*a]]
+        end
+        
+      }
+    end
+
+    def curry(one)
+      Lambda.new { |*args| self[one, *args] }
+    end
+
+    def uncurry()
+      Lambda.new { |*args| self[args[0]] }
+    end
+
+  end # class Lambda
+
+end # Prelude

data/lib/prelude/minimal_array_list.rb

@@ -0,0 +1,61 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+# $Id: minimal_array_list.rb 34 2007-10-23 21:38:09Z prelude $
+
+require 'prelude/proper_ruby_list'
+
+module Prelude
+
+  # This is an impementation of the minimally useful list based on Ruby arrays.
+  class MinimalArrayList
+    include Prelude::ProperRubyList
+
+    def initialize(a=nil)
+      @arr = (!a.nil? and a.kind_of?(Array)) ? a : []
+      self
+    end
+
+    def cons(v)
+      self.class.new([v]+@arr)
+    end
+
+    def head
+      raise EmptyListError if null
+      @arr[0]
+    end
+
+    def tail
+      raise EmptyListError if null
+      self.class.new(@arr[1..-1])
+    end
+
+    def null
+      @arr.length == 0
+    end
+
+    def to_a
+      @arr
+    end
+
+  end # ArrayList
+end # Prelude

data/lib/prelude/monad.rb

@@ -23,22 +23,23 @@
 
 module Prelude
 
-  # $Id: monad.rb 13 2006-09-11 05:19:16Z prelude $
+  # $Id: monad.rb 34 2007-10-23 21:38:09Z prelude $
   #
+  # Defines monadic behavior for anything willing to include it.
   module Monad
-    State = {}
+    M_STATE = {}
 
     def wrap
-      State[object_id] = self
+      M_STATE[object_id] = self
       self
     end
 
     def unwrap
-      State[object_id]
+      M_STATE[object_id]
     end
 
     def empty
-      State[object_id] = nil
+      M_STATE[object_id] = nil
       self
     end
     
@@ -49,21 +50,16 @@ module Prelude
     end
 
     def bind(f=nil)
-      case
-      when f.kind_of?(Symbol) || f.kind_of?(Method) || f.kind_of?(Proc) :
-          State[object_id] = f.to_proc.call(State[object_id])
+      wrap unless M_STATE[object_id]
+      if f.kind_of?(Symbol) || f.kind_of?(Method) || f.kind_of?(Proc)
+        M_STATE[object_id] = f.to_proc.call(M_STATE[object_id])
         self
-        
-#      when f.kind_of?(Proc) :
-#          State[object_id] = f.call(State[object_id])
-#        self
-
       else
         f
-      end # case
+      end # if
     end # bind
 
-    alias << bind
+    alias >> bind
 
   end # Monad
 

data/lib/prelude/proper_list.rb

@@ -0,0 +1,47 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+module Prelude
+
+  # $Id: proper_list.rb 34 2007-10-23 21:38:09Z prelude $
+  #
+  # Requires (but does not implement) 4 functions a proper list just cannot do without.
+  module ProperList
+    def cons(v)
+      raise MissingMethodError.new("Method 'cons' is not implemented by #{self.class.name}")
+    end
+
+    def head
+      raise MissingMethodError.new("Method 'head' is not implemented by #{self.class.name}")
+    end
+
+    def tail
+      raise MissingMethodError.new("Method 'tail' is not implemented by #{self.class.name}")
+    end
+
+    def null
+      raise MissingMethodError.new("Method 'null' is not implemented by #{self.class.name}")
+    end
+
+  end # ProperList
+end # Prelude

data/lib/prelude/proper_ruby_list.rb

@@ -0,0 +1,48 @@
+#-- 
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+require 'prelude/proper_list'
+
+module Prelude
+
+  # $Id: proper_ruby_list.rb 34 2007-10-23 21:38:09Z prelude $
+  #
+  # Adds (but does not implement) 3 functions to a ProperList to make a well-behaved 
+  # Ruby list.
+  module ProperRubyList
+    include Prelude::ProperList
+
+    def initialize(a=nil)
+      raise MissingMethodError.new("Method 'initialize' is not implemented by #{self.class.name}")
+    end
+
+    def to_a
+      raise MissingMethodError.new("Method 'to_a' is not implemented by #{self.class.name}")
+    end
+
+    def each(&block)
+      self.to_a.each(&block)
+    end
+
+  end # ProperRubyList
+end # Prelude

data/lib/prelude/util.rb

@@ -0,0 +1,33 @@
+#--
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+# $Id: util.rb 28 2006-12-19 00:12:54Z prelude $
+#
+class Symbol
+  
+  # Converts a symbol to a proc object
+  def to_proc
+    proc { |obj, *args| obj.send(self, *args) }
+  end
+
+end # Symbol

data/test/tc_functions.rb

@@ -0,0 +1,801 @@
+#--
+# $Id: tc_functions.rb 30 2006-12-27 23:00:53Z prelude $
+#
+#
+#     This file is part of the Prelude library that provides tools to
+#     enable Haskell style functional programming in Ruby.
+#
+#     http://prelude.rubyforge.org 
+#     
+#     Copyright (C) 2006 APP Design, Inc.
+#
+#     This library is free software; you can redistribute it and/or
+#     modify it under the terms of the GNU Lesser General Public
+#     License as published by the Free Software Foundation; either
+#     version 2.1 of the License, or (at your option) any later version.
+#
+#     This library is distributed in the hope that it will be useful,
+#     but WITHOUT ANY WARRANTY; without even the implied warranty of
+#     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#     Lesser General Public License for more details.
+#
+#     You should have received a copy of the GNU Lesser General Public
+#     License along with this library; if not, write to the Free Software
+#     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+#++
+
+require 'prelude'
+require 'test/unit'
+
+class TestFunctions < Test::Unit::TestCase
+
+  include Prelude
+
+  def setup
+
+    @a0         = Prelude.new_list
+    @a1         = Prelude.new_list([1])
+    @a3         = Prelude.new_list([1, 2, 3])
+    @a5         = Prelude.new_list([1, 2, 3, 4, 5])
+    @true_list  = Prelude.new_list([true, true, true])
+    @false_list = Prelude.new_list([false, false, false])
+    @mixed_list = Prelude.new_list([false, true, false])
+
+  end # setup
+
+  def teardown
+    # Nothing
+  end # teardown
+
+  # (:)/cons :: A -> [A] -> [A]
+  def test_cons
+    result = @a5.cons(0).to_a
+    expect = [0, 1, 2, 3, 4, 5]
+    assert_equal(expect, result)
+
+    result = @a0.cons(0).to_a
+    expect = [0]
+    assert_equal(expect, result)
+
+    result = @a0.cons([0, 1]).to_a
+    expect = [[0, 1]]
+    assert_equal(expect, result)
+  end
+
+  # (++)/append :: [a] -> [a] -> [a]
+  def test_append
+    result = APPEND[@a1, @a5].to_a
+    expect = [1, 1, 2, 3, 4, 5].to_a
+    assert_equal(expect, result)
+
+    result = APPEND[@a5, @a5].to_a
+    expect = [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
+    assert_equal(expect, result)
+    
+    result = APPEND[@a0, @a5].to_a
+    expect = [1, 2, 3, 4, 5]
+    assert_equal(expect, result)
+    
+    result = APPEND[@a5, @a0].to_a
+    expect = [1, 2, 3, 4, 5]
+    assert_equal(expect, result)
+  end
+
+  # head :: [a] -> a
+  def test_head
+    result = @a5.head
+    expect = 1
+    assert_equal(expect, result)
+    
+    assert_raise(EmptyListError) { @a0.head }
+  end
+  
+  # last :: [a] -> a
+  def test_last
+    result = LAST[@a5]
+    expect = 5
+    assert_equal(expect, result)
+
+    assert_raise(EmptyListError) { LAST[@a0] }
+  end
+  
+  # tail :: [a] -> [a]
+  def test_tail
+    result = @a5.tail.to_a
+    expect = [2, 3, 4, 5]
+    assert_equal(expect, result)
+
+    assert_raise(EmptyListError) { @a0.tail }
+  end
+
+  # init :: [a] -> [a]
+  def test_init
+    result = INIT[@a5].to_a
+    expect = [1, 2, 3, 4]
+    assert_equal(expect, result)
+
+    result = INIT[@a1].to_a
+    expect = []
+    assert_equal(expect, result)
+
+    assert_raise(EmptyListError) { INIT[@a0] }
+  end
+
+  # null :: [a] -> Bool
+  def test_null
+    result = @a5.null
+    expect = false
+    assert_equal(expect, result)
+
+    result = @a0.null
+    expect = true
+    assert_equal(expect, result)
+  end
+
+  # length :: [a] -> Int
+  def test_length
+    result = LENGTH[@a5]
+    expect = 5
+    assert_equal(expect, result)
+
+    result = LENGTH[@a0]
+    expect = 0
+    assert_equal(expect, result)
+
+    result = LENGTH[@a1]
+    expect = 1
+    assert_equal(expect, result)
+  end
+
+  # flip :: (a -> b -> c) -> b -> a -> c
+  def test_flip
+    result = MINUS[5, 10]
+    expect = -5
+    assert_equal(expect, result)
+
+    result = FLIP[MINUS, 5, 10]
+    expect = 5
+    assert_equal(expect, result)
+  end
+
+  # map :: (a -> b) -> [a] -> [b]
+  def test_map
+    expect = [2, 3, 4, 5, 6]
+    result = MAP[INC, @a5].to_a
+    assert_equal(expect, result)
+  end
+
+  # reverse :: [a] -> [a]
+  def test_reverse
+    result = REVERSE[@a5].to_a
+    expect = [5, 4, 3, 2, 1]
+    assert_equal(expect, result)
+  end
+
+  # reverse1 :: [a] -> [a]
+  def test_reverse1
+    result = REVERSE1[@a5].to_a
+    expect = [5, 4, 3, 2, 1]
+    assert_equal(expect, result)
+  end
+
+  # reverse2 :: [a] -> [a]
+  def test_reverse2
+    result = REVERSE2[@a5].to_a
+    expect = [5, 4, 3, 2, 1]
+    assert_equal(expect, result)
+  end
+
+  # reverse3 :: [a] -> [a]
+  def test_reverse3
+    result = REVERSE3[@a5].to_a
+    expect = [5, 4, 3, 2, 1]
+    assert_equal(expect, result)
+  end
+
+  # intersperse :: a -> [a] -> [a]
+  def test_intersperse
+    result = INTERSPERSE[0, @a5].to_a
+    expect = [1, 0, 2, 0, 3, 0, 4, 0, 5]
+
+    assert_equal(expect, result)
+  end
+
+# #   # transpose :: [[a]] -> [[a]]
+# #   def test_transpose
+# #     result = ~transpose([@a5, @a5, @a5])
+# #     expect = [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4], [5, 5, 5] ]
+
+# #     assert_equal(expect, result)
+# #   end
+
+  #   # * Reducing lists (folds)
+
+  # foldl :: (a -> b -> a) -> a -> [b] -> a
+  def test_foldl
+    expect = 15
+    result = FOLDL[PLUS, 0, @a5]
+    assert_equal(expect, result)
+  end
+
+  # foldl' :: (a -> b -> a) -> a -> [b] -> a
+  def test_foldl_
+    result = FOLDL_[PLUS, 0, @a5]
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # foldl1 :: (a -> a -> a) -> [a] -> a
+  def test_foldl1
+    expect = 15
+    result = FOLDL1[PLUS, @a5]
+    assert_equal(expect, result)
+  end
+
+  # foldl1' :: (a -> a -> a) -> [a] -> a
+  def test_foldl1_
+    result = FOLDL1_[PLUS, @a5]
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # foldr :: (a -> b -> b) -> b -> [a] -> b
+  def test_foldr
+    expect = 15
+    result = FOLDR[PLUS, 0, @a5]
+    assert_equal(expect, result)
+  end
+
+  # foldr1 :: (a -> a -> a) -> [a] -> a
+  def test_foldr1
+    expect = 15
+    result = FOLDR1[PLUS, @a5]
+    assert_equal(expect, result)
+  end
+
+#   # ** Special folds
+
+  # concat :: [[a]] -> [a]
+  def test_concat
+    result = CONCAT[ Prelude.new_list([[1, 2, [1, 2]], [1, 2]])].to_a
+    expect = [1, 2, [1, 2], 1, 2]
+    assert_equal(expect, result)
+  end
+
+  # concatMap :: (a -> [b]) -> [a] -> [b]
+  def test_concat_map
+    result = CONCAT_MAP[Lambda.new { |x| Prelude.new_list([x, x]) }, @a5].to_a
+    expect = [1, 1, 2, 2, 3, 3, 4, 4, 5, 5]
+
+    assert_equal(expect, result)
+  end
+
+  # and :: [Bool] -> Bool
+  def test_and
+    result = AND[@true_list]
+    expect = true
+    assert_equal(expect, result)
+
+    result = AND[@mixed_list]
+    expect = false
+    assert_equal(expect, result)
+
+    result = AND[@false_list]
+    expect = false
+    assert_equal(expect, result)
+  end
+
+  # or :: [Bool] -> Bool
+  def test_or
+    result = OR[@true_list]
+    expect = true
+    assert_equal(expect, result)
+
+    result = OR[@mixed_list]
+    expect = true
+    assert_equal(expect, result)
+
+    result = OR[@false_list]
+    expect = false
+    assert_equal(expect, result)
+  end
+
+  # any :: (a -> Bool) -> [a] -> Bool
+  def test_any
+    f1 = lambda {|x| x>5}
+    f2 = lambda {|x| x<5}
+
+    result = ANY[f1, @a5]
+    expect = false
+    assert_equal(expect, result)
+
+    result = ANY[f2, @a5]
+    expect = true
+    assert_equal(expect, result)
+  end
+
+  # all :: (a -> Bool) -> [a] -> Bool
+  def test_all
+    result = ALL[lambda {|x| x>3}, @a5]
+    expect = false
+    assert_equal(expect, result)
+
+    result = ALL[lambda {|x| x>0}, @a5]
+    expect = true
+    assert_equal(expect, result)
+  end
+
+  # sum :: (Num a) => [a] -> a
+  def test_sum
+    result = SUM
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # product :: (Num a) => [a] -> a
+  def test_product
+    result = PRODUCT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # maximum :: (Ord a) => [a] -> a
+  def test_maximum
+    result = MAXIMUM
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # minimum :: (Ord a) => [a] -> a
+  def test_minimum
+    result = MINIMUM
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Building lists
+
+  # ** Scans
+  # scanl :: (a -> b -> a) -> a -> [b] -> [a]
+  def test_scanl
+    result = SCANL
+    expect = NOT_IMPLEMENTED_YET #[0, 1, 3, 6, 10, 15]
+    assert_equal(expect, result)
+  end
+
+  # scanl1 :: (a -> a -> a) -> [a] -> [a]
+  def test_scanl1
+    result = SCANL1
+    expect = NOT_IMPLEMENTED_YET #[1, 3, 6, 10, 15]
+    assert_equal(expect, result)
+  end
+
+  # scanr :: (a -> b -> b) -> b -> [a] -> [b]
+  def test_scanr
+    result = SCANR
+    expect = NOT_IMPLEMENTED_YET #[0, 1, 3, 6, 10, 15]
+    assert_equal(expect, result)
+  end
+
+  # scanr1 :: (a -> a -> a) -> [a] -> [a]
+  def test_scanr1
+    result = SCANR1
+    expect = NOT_IMPLEMENTED_YET #[1, 3, 6, 10, 15]
+    assert_equal(expect, result)
+  end
+
+
+  # ** Accumulating maps
+  # mapAccumL :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+  def test_map_accum_l
+    result = MAP_ACCUM_L
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # mapAccumR :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+  def test_map_accum_r
+    result = MAP_ACCUM_R
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # ** Infinite lists
+  # iterate :: (a -> a) -> a -> [a]
+  def test_iterate
+    result = ITERATE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # repeat :: a -> [a]
+  def test_repeat
+    result = REPEAT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # replicate :: Int -> a -> [a]
+  def test_replicate
+    result = REPLICATE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # cycle :: [a] -> [a]
+  def test_cycle
+    result = CYCLE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # ** Unfolding
+  # unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
+  def test_unfoldr
+    result = UNFOLDR
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Sublists
+
+  # ** Extracting sublists
+  # take :: Int -> [a] -> [a]
+  def test_take
+    result = TAKE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # drop :: Int -> [a] -> [a]
+  def test_drop
+    result = DROP
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # splitAt :: Int -> [a] -> ([a], [a])
+  def test_split_at
+    result = SPLIT_AT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # takeWhile :: (a -> Bool) -> [a] -> [a]
+  def test_take_while
+    result = TAKE_WHILE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # dropWhile :: (a -> Bool) -> [a] -> [a]
+  def test_drop_while
+    result = DROP_WHILE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # span :: (a -> Bool) -> [a] -> ([a], [a])
+  def test_span
+    result = SPAN
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # break :: (a -> Bool) -> [a] -> ([a], [a])
+  def test_break_
+    result = BREAK_
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # group :: Eq a => [a] -> [[a]]
+  def test_group
+    result = GROUP
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # inits :: [a] -> [[a]]
+  def test_inits
+    result = INITS
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # tails :: [a] -> [[a]]
+  def test_tails
+    result = TAILS
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # ** Predicates
+  # isPrefixOf :: (Eq a) => [a] -> [a] -> Bool
+  def test_is_prefix_of
+    result = IS_PREFIX_OF
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # isSuffixOf :: (Eq a) => [a] -> [a] -> Bool
+  def test_is_suffix_of
+    result = IS_SUFFIX_OF
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Searching lists
+
+  # ** Searching by equality
+  # elem :: a -> [a] -> Bool
+  def test_elem
+    result = ELEM
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # notElem :: a -> [a] -> Bool
+  def test_not_elem
+    result = NOT_ELEM
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # lookup :: (Eq a) => a -> [(a,b)] -> Maybe b
+  def test_lookup
+    result = LOOKUP
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # ** Searching with a predicate
+  # find :: (a -> Bool) -> [a] -> Maybe a
+  def test_find
+    result = FIND
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # filter :: (a -> Bool) -> [a] -> [a]
+  def test_filter
+    result = FILTER
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # partition :: (a -> Bool) -> [a] -> ([a], [a])
+  def test_partition
+    result = PARTITION
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Indexing lists
+  # | These functions treat a list @xs@ as a indexed collection,
+  # with indices ranging from 0 to @'length' xs - 1@.
+
+  # (!!) :: [a] -> Int -> a
+  # Don't know how to implement it in Ruby
+
+
+  # elemIndex :: (Eq a) => a -> [a] -> Maybe Int
+  def test_elem_index
+    result = ELEM_INDEX
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # elemIndices :: (Eq a) => a -> [a] -> [Int]
+  def test_elem_indices
+    result = ELEM_INDICES
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # findIndex :: (a -> Bool) -> [a] -> Maybe Int
+  def test_find_index
+    result = FIND_INDEX
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # findIndices :: (a -> Bool) -> [a] -> [Int]
+  def test_find_indices
+    result = FIND_INDICES
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Zipping and unzipping lists
+
+  # zip :: [a] -> [b] -> [(a,b)]
+  def test_zip
+    result = ZIP[@a5, @a5].to_a
+    expect = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5] ]
+    assert_equal(expect, result)
+
+    result = ZIP[@a5, @a3].to_a
+    expect = [[1, 1], [2, 2], [3, 3] ]
+    assert_equal(expect, result)
+
+    result = ZIP[@a3, @a5].to_a
+    expect = [[1, 1], [2, 2], [3, 3] ]
+    assert_equal(expect, result)
+
+    result = ZIP[@a3, @a0].to_a
+    expect = []
+    assert_equal(expect, result)
+
+    result = ZIP[@a0, @a3]
+    expect = []
+    assert_equal(expect, result)
+
+    result = ZIP[@a1, @a3].to_a
+    expect = [[1,1]]
+    assert_equal(expect, result)
+
+    result = ZIP[@a3, @a1].to_a
+    expect = [[1,1]]
+    assert_equal(expect, result)
+
+    result = ZIP[@a1, @a0].to_a
+    expect = []
+    assert_equal(expect, result)
+
+    result = ZIP[@a0, @a1].to_a
+    expect = []
+    assert_equal(expect, result)
+  end
+
+  # zip3  
+  def test_zip3
+    result = ZIP3
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # zip4, zip5, zip6, zip7
+  def test_zip4
+    result = ZIP4
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+  def test_zip_with
+    result = ZIP_WITH
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # zipWith3
+  def test_zip_with3
+    result = ZIP_WITH3
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # zipWith4, zipWith5, zipWith6, zipWith7
+  def test_zip_with4
+    result = ZIP_WITH4
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # unzip :: [(a,b)] -> ([a],[b])
+  def test_unzip
+    result = UNZIP
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # unzip3
+  def test_unzip3
+    result = UNZIP3
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # unzip4, unzip5, unzip6, unzip7
+  def test_unzip4
+    result = UNZIP4
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # * Special lists
+
+  # ** Functions on strings
+  # lines :: String   -> [String]
+  def test_lines
+    result = LINES
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # words :: String   -> [String]
+  def test_words
+    result = WORDS
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # unlines :: [String] -> String
+  def test_unlines
+    result = UNLINES
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # unwords :: [String] -> String
+  def test_unwords
+    result = UNWORDS
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # ** \"Set\" operations
+  
+  # nub :: (Eq a) => [a] -> [a]
+  def test_nub
+    result = NUB
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # delete :: (Eq a) => a -> [a] -> [a]
+  def test_delete
+    result = DELETE
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # (\\) :: (Eq a) => [a] -> [a] -> [a]
+  # Don't know how to implement it in Ruby
+
+  # union :: (Eq a) => [a] -> [a] -> [a]
+  def test_union
+    result = UNION
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # intersect :: (Eq a) => [a] -> [a] -> [a]
+  def test_intersect
+    result = INTERSECT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+
+  # ** Ordered lists
+
+  # sort :: (Ord a) => [a] -> [a]
+  def test_sort
+    result = SORT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+  # insert :: (Ord a) => a -> [a] -> [a]
+  def test_insert
+    result = INSERT
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
+end # TestList