prelude 0.0.2 → 0.0.3

data/lib/prelude/monad.rb

@@ -23,29 +23,106 @@
 
 module Prelude
 
-  # $Id: monad.rb 7 2006-09-06 17:03:26Z prelude $
+  # $Id: monad.rb 13 2006-09-11 05:19:16Z prelude $
   #
-  # The Monad is an Array only in an implementation sence of the word
-  class Monad < Array
+  module Monad
+    State = {}
 
-    def wrap(v)
-      [v]
+    def wrap
+      State[object_id] = self
+      self
+    end
+
+    def unwrap
+      State[object_id]
     end
 
     def empty
-      []
+      State[object_id] = nil
+      self
     end
     
-    def join
+    def Monad.join(arr)
       r = []
-      each {|a| r.push *a}
+      arr.each {|a| r.push *a}
       r
     end
 
-    def bind(&block)
-      map(&block).join
-    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])
+        self
+        
+#      when f.kind_of?(Proc) :
+#          State[object_id] = f.call(State[object_id])
+#        self
+
+      else
+        f
+      end # case
+    end # bind
+
+    alias << bind
 
   end # Monad
 
+#   class Maybe < Monad
+    
+#     # maybe		-- :: b -> (a -> b) -> Maybe a -> b
+#     def maybe
+#       warn "Method 'maybe' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # isJust		-- :: Maybe a -> Bool
+#     def isJust
+#       warn "Method 'isJust' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # isNothing		-- :: Maybe a -> Bool
+#     def isNothing
+#       warn "Method 'isNothing' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # fromJust		-- :: Maybe a -> a
+#     def fromJust
+#       warn "Method 'fromJust' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # fromMaybe		-- :: a -> Maybe a -> a
+#     def fromMaybe
+#       warn "Method 'fromMaybe' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # listToMaybe       -- :: [a] -> Maybe a
+#     def listToMaybe
+#       warn "Method 'listToMaybe' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # maybeToList	-- :: Maybe a -> [a]
+#     def maybeToList
+#       warn "Method 'maybeToList' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # catMaybes		-- :: [Maybe a] -> [a]
+#     def catMaybes
+#       warn "Method 'catMaybes' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#     # mapMaybe		-- :: (a -> Maybe b) -> [a] -> [b]
+#     def mapMaybe
+#       warn "Method 'mapMaybe' is not implemented yet." if $VERBOSE
+#       return []
+#     end
+
+#   end # Maybe
+
 end # Prelude

data/test/tc_higher.rb

@@ -1,5 +1,5 @@
 #--
-# $Id: tc_higher.rb 7 2006-09-06 17:03:26Z prelude $
+# $Id: tc_higher.rb 17 2006-09-17 18:03:15Z prelude $
 #
 #
 #     This file is part of the Prelude library that provides tools to
@@ -65,22 +65,22 @@ class TestHigher < Test::Unit::TestCase
     assert_equal(expect, result)
   end
 
-  def test_stream
+  def test_composition
     add5 = proc {|x| x+5}
     add6 = proc {|x,y| x+y+6}
-    add11 = add5 << add6
+    add11 = add5 ** add6
 
     result = add11[1, 2]
     expect = 14
     
     assert_equal(expect, result)
 
-    result = add5 << 1
+    result = add5 ** 1
     expect = 6
     
     assert_equal(expect, result)
 
-    result = add5 << add6 << [1, 2]
+    result = add5 ** add6 ** [1, 2]
     expect = 14
     
     assert_equal(expect, result)

data/test/tc_list.rb

@@ -1,5 +1,5 @@
 #--
-# $Id: tc_list.rb 7 2006-09-06 17:03:26Z prelude $
+# $Id: tc_list.rb 17 2006-09-17 18:03:15Z prelude $
 #
 #
 #     This file is part of the Prelude library that provides tools to
@@ -26,12 +26,16 @@
 
 class TestList < Test::Unit::TestCase
 
+  include List
+
+  NOT_IMPLEMENTED_YET = []
+
   def setup
 
-    @a          = List.new([1, 2, 3, 4, 5])
-    @true_list  = List.new([true, true, true])
-    @false_list = List.new([false, false, false])
-    @mixed_list = List.new([false, true, false])
+    @a          = [1, 2, 3, 4, 5]
+    @true_list  = [true, true, true]
+    @false_list = [false, false, false]
+    @mixed_list = [false, true, false]
 
   end # setup
 
@@ -39,114 +43,90 @@ class TestList < Test::Unit::TestCase
     # Nothing
   end # teardown
 
+  # head           -- :: [a] -> a
   def test_head
-    result = @a.head
+    result = ~head(@a)
     expect = 1
-
-    assert_equal(expect, result)
-  end
-
-  # Compatibility with the Array class
-  def test_array_plus
-    b = [6, 7]
-
-    result = @a+b
-    expect = [1, 2, 3, 4, 5, 6, 7]
-
-    assert_instance_of(List, result)
-    assert_equal(expect, result)
-  end
-
-  def test_array_assignment
-    @a[1] = 10
-    result = @a
-    expect = [1, 10, 3, 4, 5]
     
-    assert_instance_of(List, result)
     assert_equal(expect, result)
-  end
-  
-  def test_array_shift
-    result = @a << 100 << 101
-    expect = [1, 2, 3, 4, 5, 100, 101]
     
-    assert_instance_of(List, result)
-    assert_equal(expect, result)
+    assert_raise(EmptyListError) { ~head([]) }
   end
-    
-  #    , last	       -- :: [a] -> a
+  
+  # last	       -- :: [a] -> a
   def test_last
-    result = @a.last
+    result = ~last(@a)
     expect = 5
 
     assert_equal(expect, result)
+
+    assert_raise(EmptyListError) { last [] }
   end
   
-  #    , tail	       -- :: [a] -> [a]
+  # tail	       -- :: [a] -> [a]
   def test_tail
-    result = @a.tail
+    result = ~tail(@a)
     expect = [2, 3, 4, 5]
 
     assert_equal(expect, result)
+
+    assert_raise(EmptyListError) { ~tail([]) }
   end
 
-  #    , init              -- :: [a] -> [a]
+  # init              -- :: [a] -> [a]
   def test_init
-    result = @a.init
+    result = ~init(@a)
     expect = [1, 2, 3, 4]
 
     assert_equal(expect, result)
+
+    assert_equal( ~init([1]), [])
+    assert_raise(EmptyListError) { ~init([]) }
   end
 
-  #    , null	       -- :: [a] -> Bool
+  # null	       -- :: [a] -> Bool
   def test_null
-    result = @a.null
+    result = ~null(@a)
     expect = false
 
     assert_equal(expect, result)
   end
 
-  #    , length	       -- :: [a] -> Int
+  # length	       -- :: [a] -> Int
   def test_length
-    result = @a.length
+    result = ~length(@a)
     expect = 5
 
     assert_equal(expect, result)
   end
 
-  #    , map               -- :: (a -> b) -> [a] -> [b]
+  # map               -- :: (a -> b) -> [a] -> [b]
   def test_map
-    result = @a.map{|x| x+1}
-    expect = [2, 3, 4, 5, 6]
-
-    assert_equal(expect, result)
-
-    p = proc {|x| x+1}
-    result = @a.map(&p)
     expect = [2, 3, 4, 5, 6]
 
+    result = ~map(proc {|x| x+1}, @a)
     assert_equal(expect, result)
   end
 
-  #    , reverse           -- :: [a] -> [a]
+  # reverse           -- :: [a] -> [a]
   def test_reverse
-    result = @a.reverse
+    result = ~reverse(@a)
     expect = [5, 4, 3, 2, 1]
 
     assert_equal(expect, result)
   end
 
-  #    , intersperse       -- :: a -> [a] -> [a]
+  # intersperse       -- :: a -> [a] -> [a]
   def test_intersperse
-    result = @a.intersperse
-    expect = []
+    result = ~intersperse(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , transpose         -- :: [[a]] -> [[a]]
+  # transpose         -- :: [[a]] -> [[a]]
   def test_transpose
-    result = List.new([@a, @a, @a]).transpose
+    result = ~transpose([@a, @a, @a])
     expect = [[1, 1, 1], [2, 2, 2], [3, 3, 3], [4, 4, 4], [5, 5, 5] ]
 
     assert_equal(expect, result)
@@ -154,173 +134,178 @@ class TestList < Test::Unit::TestCase
 
   #    -- * Reducing lists (folds)
 
-  #    , foldl	       -- :: (a -> b -> a) -> a -> [b] -> a
+  # foldl	       -- :: (a -> b -> a) -> a -> [b] -> a
 
-  # Classic recursive functional definition causes stack overflow for
-  # arrays of any usable size... So don't use it, it's here for completeness
-  def test_f_foldl
-    result = @a.f_foldl(0){ |x, y| x+y}
+  def test_foldl
     expect = 15
 
+    result = ~foldl(proc{ |x, y| x+y}, 0, @a )
     assert_equal(expect, result)
-  end
-
-  # This is a more pedestrian iterative version.
-  def test_foldl
-    result = @a.foldl(0){ |x, y| x+y}
-    expect = 15
 
+    result = ~foldl(-:+, 0, @a )
     assert_equal(expect, result)
   end
 
-  #    , foldl'	       -- :: (a -> b -> a) -> a -> [b] -> a
+  # foldl'	       -- :: (a -> b -> a) -> a -> [b] -> a
   def test_foldl_
-    result = @a.foldl_
-    expect = []
+    result = ~foldl_(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , foldl1	       -- :: (a -> a -> a) -> [a] -> a
+  # foldl1	       -- :: (a -> a -> a) -> [a] -> a
   def test_foldl1
-    result = @a.foldl1{ |x, y| x*y}
-    expect = 120
+    expect = 15
 
+    result = ~foldl1( proc{ |x, y| x+y}, @a )
+    assert_equal(expect, result)
+
+    result = ~foldl1(-:+, @a )
     assert_equal(expect, result)
   end
 
-  #    , foldl1'	       -- :: (a -> a -> a) -> [a] -> a
+  # foldl1'	       -- :: (a -> a -> a) -> [a] -> a
   def test_foldl1_
-    result = @a.foldl1_
-    expect = []
+    result = ~foldl1_(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , foldr             -- :: (a -> b -> b) -> b -> [a] -> b
+  # foldr             -- :: (a -> b -> b) -> b -> [a] -> b
   def test_foldr
-    result = @a.foldr(0){ |x, y| x+y}
     expect = 15
 
+    result = ~foldr(proc{ |x, y| x+y}, 0, @a)
+    assert_equal(expect, result)
+
+    result = ~foldr(-:+, 0, @a )
     assert_equal(expect, result)
   end
 
-  #    , foldr1            -- :: (a -> a -> a) -> [a] -> a
+  # foldr1            -- :: (a -> a -> a) -> [a] -> a
   def test_foldr1
-    result = @a.foldr1{ |x, y| x*y}
-    expect = 120
+    expect = 15
 
+    result = ~foldr1(proc{ |x, y| x+y}, @a)
+    assert_equal(expect, result)
+
+    result = ~foldr1(-:+, @a)
     assert_equal(expect, result)
   end
 
   #    -- ** Special folds
 
-  #    , concat            -- :: [[a]] -> [a]
+  # concat            -- :: [[a]] -> [a]
   def test_concat
-    result = List.new([@a, [@a]]).concat
-    expect = @a+@a
+    result = ~concat( [[1, 2, [1, 2]], [1, 2]] )
+    expect = [1, 2, [1, 2], 1, 2]
 
     assert_equal(expect, result)
   end
 
-  #    , concatMap         -- :: (a -> [b]) -> [a] -> [b]
+  # concatMap         -- :: (a -> [b]) -> [a] -> [b]
   def test_concatMap
-    result = @a.concatMap
-    expect = []
+    result = ~concatMap(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , and	       -- :: [Bool] -> Bool
+  # and	       -- :: [Bool] -> Bool
   def test_and
-    result = @true_list.and
+    result = ~and_(@true_list)
     expect = true
 
     assert_equal(expect, result)
 
-    result = @mixed_list.and
+    result = ~and_(@mixed_list)
     expect = false
 
     assert_equal(expect, result)
 
-    result = @false_list.and
+    result = ~and_(@false_list)
     expect = false
 
     assert_equal(expect, result)
   end
 
-  #    , or                -- :: [Bool] -> Bool
+  # or                -- :: [Bool] -> Bool
   def test_or
-    result = @true_list.or
+    result = ~or_(@true_list)
     expect = true
 
     assert_equal(expect, result)
 
-    result = @mixed_list.or
+    result = ~or_(@mixed_list)
     expect = true
 
     assert_equal(expect, result)
 
-    result = @false_list.or
+    result = ~or_(@false_list)
     expect = false
 
     assert_equal(expect, result)
   end
 
-  #    , any               -- :: (a -> Bool) -> [a] -> Bool
+  # any               -- :: (a -> Bool) -> [a] -> Bool
   def test_any
-    result = @a.any{|x| x>5}
+    f1 = proc {|x| x>5}
+    f2 = proc {|x| x<5}
+
+    result = ~any(f1, @a)
     expect = false
 
     assert_equal(expect, result)
 
-    result = @a.any{|x| x<5}
+    result = ~any(f2, @a)
     expect = true
 
     assert_equal(expect, result)
   end
 
-  #    , all               -- :: (a -> Bool) -> [a] -> Bool
+  # all               -- :: (a -> Bool) -> [a] -> Bool
   def test_all
-    result = @a.all{|x| x>3}
+    result = ~all(proc {|x| x>3}, @a)
     expect = false
 
     assert_equal(expect, result)
 
-    result = @a.all{|x| x>0}
+    result = ~all(proc {|x| x>0}, @a)
     expect = true
 
     assert_equal(expect, result)
   end
 
-  #    , sum               -- :: (Num a) => [a] -> a
+  # sum               -- :: (Num a) => [a] -> a
   def test_sum
-    result = @a.sum
-    expect = []
+    result = ~sum(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , product           -- :: (Num a) => [a] -> a
+  # product           -- :: (Num a) => [a] -> a
   def test_product
-    result = @a.product
-    expect = []
+    result = ~product(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , maximum           -- :: (Ord a) => [a] -> a
+  # maximum           -- :: (Ord a) => [a] -> a
   def test_maximum
-    result = @a.maximum
-    expect = []
+    result = ~maximum(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , minimum           -- :: (Ord a) => [a] -> a
+  # minimum           -- :: (Ord a) => [a] -> a
   def test_minimum
-    result = @a.minimum
-    expect = []
+    result = ~minimum(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -329,96 +314,96 @@ class TestList < Test::Unit::TestCase
   #    -- * Building lists
 
   #    -- ** Scans
-  #    , scanl             -- :: (a -> b -> a) -> a -> [b] -> [a]
+  # scanl             -- :: (a -> b -> a) -> a -> [b] -> [a]
   def test_scanl
-    result = @a.scanl(0){ |x, y| x+y}
-    expect = [0, 1, 3, 6, 10, 15]
+    result = ~scanl(lambda{ |x, y| x+y}, 0, @a)
+    expect = NOT_IMPLEMENTED_YET #[0, 1, 3, 6, 10, 15]
 
     assert_equal(expect, result)
   end
 
-  #    , scanl1            -- :: (a -> a -> a) -> [a] -> [a]
+  # scanl1            -- :: (a -> a -> a) -> [a] -> [a]
   def test_scanl1
-    result = @a.scanl1{ |x, y| x+y}
-    expect = [1, 3, 6, 10, 15]
+    result = ~scanl1( lambda { |x, y| x+y }, @a)
+    expect = NOT_IMPLEMENTED_YET #[1, 3, 6, 10, 15]
 
     assert_equal(expect, result)
   end
 
-  #    , scanr             -- :: (a -> b -> b) -> b -> [a] -> [b]
+  # scanr             -- :: (a -> b -> b) -> b -> [a] -> [b]
   def test_scanr
-    result = @a.scanr(0){ |x, y| x+y}
-    expect = [0, 1, 3, 6, 10, 15]
+    result = ~scanr(lambda { |x, y| x+y }, 0, @a)
+    expect = NOT_IMPLEMENTED_YET #[0, 1, 3, 6, 10, 15]
 
     assert_equal(expect, result)
   end
 
-  #    , scanr1            -- :: (a -> a -> a) -> [a] -> [a]
+  # scanr1            -- :: (a -> a -> a) -> [a] -> [a]
   def test_scanr1
-    result = @a.scanr1{ |x, y| x+y}
-    expect = [1, 3, 6, 10, 15]
+    result = ~scanr1(lambda { |x, y| x+y }, @a)
+    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])
+  # mapAccumL         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
   def test_mapAccumL
-    result = @a.mapAccumL
-    expect = []
+    result = ~mapAccumL(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , mapAccumR         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
+  # mapAccumR         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
   def test_mapAccumR
-    result = @a.mapAccumR
-    expect = []
+    result = ~mapAccumR(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
   #    -- ** Infinite lists
-  #    , iterate           -- :: (a -> a) -> a -> [a]
+  # iterate           -- :: (a -> a) -> a -> [a]
   def test_iterate
-    result = @a.iterate
-    expect = []
+    result = ~iterate(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , repeat            -- :: a -> [a]
+  # repeat            -- :: a -> [a]
   def test_repeat
-    result = @a.repeat
-    expect = []
+    result = ~repeat(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , replicate         -- :: Int -> a -> [a]
+  # replicate         -- :: Int -> a -> [a]
   def test_replicate
-    result = @a.replicate
-    expect = []
+    result = ~replicate(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , cycle             -- :: [a] -> [a]
+  # cycle             -- :: [a] -> [a]
   def test_cycle
-    result = @a.cycle
-    expect = []
+    result = ~cycle(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
   #    -- ** Unfolding
-  #    , unfoldr	       -- :: (b -> Maybe (a, b)) -> b -> [a]
+  # unfoldr	       -- :: (b -> Maybe (a, b)) -> b -> [a]
   def test_unfoldr
-    result = @a.unfoldr
-    expect = []
+    result = ~unfoldr(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -427,99 +412,99 @@ class TestList < Test::Unit::TestCase
   #    -- * Sublists
 
   #    -- ** Extracting sublists
-  #    , take              -- :: Int -> [a] -> [a]
+  # take              -- :: Int -> [a] -> [a]
   def test_take
-    result = @a.take(2)
+    result = ~take(2, @a)
     expect = [1, 2]
 
     assert_equal(expect, result)
   end
 
-  #    , drop              -- :: Int -> [a] -> [a]
+  # drop              -- :: Int -> [a] -> [a]
   def test_drop
-    result = @a.drop(2)
+    result = ~drop(2, @a)
     expect = [3, 4, 5]
 
     assert_equal(expect, result)
   end
 
-  #    , splitAt           -- :: Int -> [a] -> ([a], [a])
+  # splitAt           -- :: Int -> [a] -> ([a], [a])
   def test_split_at
-    result = @a.split_at(2)
+    result = ~split_at(2, @a)
     expect = [[1, 2],[3, 4, 5]]
 
     assert_equal(expect, result)
   end
 
-  #    , takeWhile         -- :: (a -> Bool) -> [a] -> [a]
+  # takeWhile         -- :: (a -> Bool) -> [a] -> [a]
   def test_takeWhile
-    result = @a.takeWhile{|x| x<4}
+    result = ~takeWhile(lambda {|x| x<4}, @a)
     expect = [1, 2, 3]
 
     assert_equal(expect, result)
   end
 
-  #    , dropWhile         -- :: (a -> Bool) -> [a] -> [a]
+  # dropWhile         -- :: (a -> Bool) -> [a] -> [a]
   def test_dropWhile
-    result = @a.dropWhile{|x| x<4}
+    result = ~dropWhile(lambda {|x| x<4}, @a)
     expect = [4, 5]
 
     assert_equal(expect, result)
   end
 
-  #    , span              -- :: (a -> Bool) -> [a] -> ([a], [a])
+  # span              -- :: (a -> Bool) -> [a] -> ([a], [a])
   def test_span
-    result = @a.span{|x| x<3}
+    result = ~span(lambda {|x| x<3}, @a)
     expect = [[1, 2], [3, 4, 5]]
 
     assert_equal(expect, result)
   end
 
-  #    , break             -- :: (a -> Bool) -> [a] -> ([a], [a])
-  def test_break
-    result = @a.break
-    expect = []
+  # break             -- :: (a -> Bool) -> [a] -> ([a], [a])
+  def test_break_
+    result = ~break_(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , group             -- :: Eq a => [a] -> [[a]]
+  # group             -- :: Eq a => [a] -> [[a]]
   def test_group
-    result = @a.group
-    expect = []
+    result = ~group(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , inits             -- :: [a] -> [[a]]
+  # inits             -- :: [a] -> [[a]]
   def test_inits
-    result = @a.inits
-    expect = []
+    result = ~inits(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , tails             -- :: [a] -> [[a]]
+  # tails             -- :: [a] -> [[a]]
   def test_tails
-    result = @a.tails
-    expect = []
+    result = ~tails(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
   #    -- ** Predicates
-  #    , isPrefixOf        -- :: (Eq a) => [a] -> [a] -> Bool
+  # isPrefixOf        -- :: (Eq a) => [a] -> [a] -> Bool
   def test_isPrefixOf
-    result = @a.isPrefixOf
-    expect = []
+    result = ~isPrefixOf(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , isSuffixOf        -- :: (Eq a) => [a] -> [a] -> Bool
+  # isSuffixOf        -- :: (Eq a) => [a] -> [a] -> Bool
   def test_isSuffixOf
-    result = @a.isSuffixOf
-    expect = []
+    result = ~isSuffixOf(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -528,51 +513,51 @@ class TestList < Test::Unit::TestCase
   #    -- * Searching lists
 
   #    -- ** Searching by equality
-  #    , elem              -- :: a -> [a] -> Bool
+  # elem              -- :: a -> [a] -> Bool
   def test_elem
-    result = @a.elem
-    expect = []
+    result = ~elem(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , notElem           -- :: a -> [a] -> Bool
+  # notElem           -- :: a -> [a] -> Bool
   def test_notElem
-    result = @a.notElem
-    expect = []
+    result = ~notElem(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , lookup            -- :: (Eq a) => a -> [(a,b)] -> Maybe b
+  # lookup            -- :: (Eq a) => a -> [(a,b)] -> Maybe b
   def test_lookup
-    result = @a.lookup
-    expect = []
+    result = ~lookup(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
   #    -- ** Searching with a predicate
-  #    , find	       -- :: (a -> Bool) -> [a] -> Maybe a
+  # find	       -- :: (a -> Bool) -> [a] -> Maybe a
   def test_find
-    result = @a.find{|x| x==3}
-    expect = 3
+    result = ~find(lambda {|x| x==3}, @a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , filter	       -- :: (a -> Bool) -> [a] -> [a]
+  # filter	       -- :: (a -> Bool) -> [a] -> [a]
   def test_filter
-    result = @a.filter
-    expect = []
+    result = ~filter(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
+  # partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
   def test_partition
-    result = @a.partition{|x| x>3}
-    expect = [[4, 5], [1, 2, 3]]
+    result = ~partition(lambda {|x| x>3}, @a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -582,39 +567,39 @@ class TestList < Test::Unit::TestCase
   #    -- | These functions treat a list @xs@ as a indexed collection,
   #    -- with indices ranging from 0 to @'length' xs - 1@.
 
-  #    , (!!)	       -- :: [a] -> Int -> a
+  # (!!)	       -- :: [a] -> Int -> a
   # Don't know how to implement it in Ruby
 
 
-  #    , elemIndex	       -- :: (Eq a) => a -> [a] -> Maybe Int
+  # elemIndex	       -- :: (Eq a) => a -> [a] -> Maybe Int
   def test_elemIndex
-    result = @a.elemIndex
-    expect = []
+    result = ~elemIndex(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
+  # elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
   def test_elemIndices
-    result = @a.elemIndices
-    expect = []
+    result = ~elemIndices(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
-  #    , findIndex	       -- :: (a -> Bool) -> [a] -> Maybe Int
+  # findIndex	       -- :: (a -> Bool) -> [a] -> Maybe Int
   def test_findIndex
-    result = @a.findIndex
-    expect = []
+    result = ~findIndex(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , findIndices       -- :: (a -> Bool) -> [a] -> [Int]
+  # findIndices       -- :: (a -> Bool) -> [a] -> [Int]
   def test_findIndices
-    result = @a.findIndices
-    expect = []
+    result = ~findIndices(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -622,76 +607,76 @@ class TestList < Test::Unit::TestCase
 
   #    -- * Zipping and unzipping lists
 
-  #    , zip               -- :: [a] -> [b] -> [(a,b)]
+  # zip               -- :: [a] -> [b] -> [(a,b)]
   def test_zip
-    result = @a.zip(@a)
-    expect = [[1, 1], [2, 2], [3, 3], [4, 4], [5, 5] ]
+    result = ~zip(@a, @a)
+    expect = NOT_IMPLEMENTED_YET #[[1, 1], [2, 2], [3, 3], [4, 4], [5, 5] ]
 
     assert_equal(expect, result)
   end
 
-  #    , zip3  
+  # zip3  
   def test_zip3
-    result = @a.zip3
-    expect = []
+    result = ~zip3(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , zip4, zip5, zip6, zip7
+  # zip4, zip5, zip6, zip7
   def test_zip4
-    result = @a.zip4
-    expect = []
+    result = ~zip4(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
-  #    , zipWith           -- :: (a -> b -> c) -> [a] -> [b] -> [c]
+  # zipWith           -- :: (a -> b -> c) -> [a] -> [b] -> [c]
   def test_zipWith
-    result = @a.zipWith
-    expect = []
+    result = ~zipWith(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , zipWith3
+  # zipWith3
   def test_zipWith3
-    result = @a.zipWith3
-    expect = []
+    result = ~zipWith3(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , zipWith4, zipWith5, zipWith6, zipWith7
+  # zipWith4, zipWith5, zipWith6, zipWith7
   def test_zipWith4
-    result = @a.zipWith4
-    expect = []
+    result = ~zipWith4(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
-  #    , unzip             -- :: [(a,b)] -> ([a],[b])
+  # unzip             -- :: [(a,b)] -> ([a],[b])
   def test_unzip
-    result = @a.unzip
-    expect = []
+    result = ~unzip(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , unzip3
+  # unzip3
   def test_unzip3
-    result = @a.unzip3
-    expect = []
+    result = ~unzip3(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , unzip4, unzip5, unzip6, unzip7
+  # unzip4, unzip5, unzip6, unzip7
   def test_unzip4
-    result = @a.unzip4
-    expect = []
+    result = ~unzip4(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -700,34 +685,34 @@ class TestList < Test::Unit::TestCase
   #    -- * Special lists
 
   #    -- ** Functions on strings
-  #    , lines	       -- :: String   -> [String]
+  # lines	       -- :: String   -> [String]
   def test_lines
-    result = @a.lines
-    expect = []
+    result = ~lines(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , words	       -- :: String   -> [String]
+  # words	       -- :: String   -> [String]
   def test_words
-    result = @a.words
-    expect = []
+    result = ~words(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , unlines           -- :: [String] -> String
+  # unlines           -- :: [String] -> String
   def test_unlines
-    result = @a.unlines
-    expect = []
+    result = ~unlines(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , unwords           -- :: [String] -> String
+  # unwords           -- :: [String] -> String
   def test_unwords
-    result = @a.unwords
-    expect = []
+    result = ~unwords(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
@@ -735,52 +720,58 @@ class TestList < Test::Unit::TestCase
 
   #    -- ** \"Set\" operations
   
-  #    , nub               -- :: (Eq a) => [a] -> [a]
+  # nub               -- :: (Eq a) => [a] -> [a]
   def test_nub
-    result = @a.nub
-    expect = []
+    result = ~nub(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
-  #    , delete            -- :: (Eq a) => a -> [a] -> [a]
+  # delete            -- :: (Eq a) => a -> [a] -> [a]
   def test_delete
-    result = @a.delete(3)
-    expect = []
+    result = ~delete(3, @a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , (\\)              -- :: (Eq a) => [a] -> [a] -> [a]
+  # (\\)              -- :: (Eq a) => [a] -> [a] -> [a]
   # Don't know how to implement it in Ruby
 
-  #    , union             -- :: (Eq a) => [a] -> [a] -> [a]
+  # union             -- :: (Eq a) => [a] -> [a] -> [a]
   def test_union
-    result = @a.union
-    expect = []
+    result = ~union(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
-  #    , intersect         -- :: (Eq a) => [a] -> [a] -> [a]
+  # intersect         -- :: (Eq a) => [a] -> [a] -> [a]
   def test_intersect
-    result = @a.intersect
-    expect = []
+    result = ~intersect(@a)
+    expect = NOT_IMPLEMENTED_YET
 
     assert_equal(expect, result)
   end
 
 
   #    -- ** Ordered lists
-  #    , sort              -- :: (Ord a) => [a] -> [a]
 
-  #    , insert            -- :: (Ord a) => a -> [a] -> [a]
-  def test_insert
-    result = @a.insert(3.5)
-    expect = []
+  # sort              -- :: (Ord a) => [a] -> [a]
+  def test_sort
+    result = ~sort(@a)
+    expect = NOT_IMPLEMENTED_YET
     
     assert_equal(expect, result)
   end
 
+  # insert            -- :: (Ord a) => a -> [a] -> [a]
+  def test_insert
+    result = ~insert(3.5, @a)
+    expect = NOT_IMPLEMENTED_YET
+    assert_equal(expect, result)
+  end
+
 end # TestList