prelude 0.0.3 → 0.0.5

data/test/tc_higher.rb

@@ -1,89 +0,0 @@
-#--
-# $Id: tc_higher.rb 17 2006-09-17 18:03:15Z 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
-#++
-
-class TestHigher < Test::Unit::TestCase
-
-  def setup
-    # Nothing
-  end # setup
-
-  def teardown
-    # Nothing
-  end # teardown
-
-  #
-  # Test higher functions
-  #
-  def test_curry_proc
-    add5 = (proc {|x,y,z| x+y+z}).curry(5)
-
-    result = add5[3, 2]
-    expect = 10
-
-    assert_equal(expect, result)
-
-    result = add5.call(3, 2)
-    expect = 10
-
-    assert_equal(expect, result)
-  end
-
-  def test_curry_symbol
-    add5 = :+.curry(5)
-
-    result = add5.call(3)
-    expect = 8
-    
-    assert_equal(expect, result)
-
-    result = add5[4]
-    expect = 9
-    
-    assert_equal(expect, result)
-  end
-
-  def test_composition
-    add5 = proc {|x| x+5}
-    add6 = proc {|x,y| x+y+6}
-    add11 = add5 ** add6
-
-    result = add11[1, 2]
-    expect = 14
-    
-    assert_equal(expect, result)
-
-    result = add5 ** 1
-    expect = 6
-    
-    assert_equal(expect, result)
-
-    result = add5 ** add6 ** [1, 2]
-    expect = 14
-    
-    assert_equal(expect, result)
-  end
-
-end # TestHigher

data/test/tc_list.rb

@@ -1,777 +0,0 @@
-#--
-# $Id: tc_list.rb 17 2006-09-17 18:03:15Z 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
-#++
-
-class TestList < Test::Unit::TestCase
-
-  include List
-
-  NOT_IMPLEMENTED_YET = []
-
-  def setup
-
-    @a          = [1, 2, 3, 4, 5]
-    @true_list  = [true, true, true]
-    @false_list = [false, false, false]
-    @mixed_list = [false, true, false]
-
-  end # setup
-
-  def teardown
-    # Nothing
-  end # teardown
-
-  # head           -- :: [a] -> a
-  def test_head
-    result = ~head(@a)
-    expect = 1
-    
-    assert_equal(expect, result)
-    
-    assert_raise(EmptyListError) { ~head([]) }
-  end
-  
-  # last	       -- :: [a] -> a
-  def test_last
-    result = ~last(@a)
-    expect = 5
-
-    assert_equal(expect, result)
-
-    assert_raise(EmptyListError) { last [] }
-  end
-  
-  # tail	       -- :: [a] -> [a]
-  def test_tail
-    result = ~tail(@a)
-    expect = [2, 3, 4, 5]
-
-    assert_equal(expect, result)
-
-    assert_raise(EmptyListError) { ~tail([]) }
-  end
-
-  # init              -- :: [a] -> [a]
-  def test_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
-  def test_null
-    result = ~null(@a)
-    expect = false
-
-    assert_equal(expect, result)
-  end
-
-  # length	       -- :: [a] -> Int
-  def test_length
-    result = ~length(@a)
-    expect = 5
-
-    assert_equal(expect, result)
-  end
-
-  # map               -- :: (a -> b) -> [a] -> [b]
-  def test_map
-    expect = [2, 3, 4, 5, 6]
-
-    result = ~map(proc {|x| x+1}, @a)
-    assert_equal(expect, result)
-  end
-
-  # reverse           -- :: [a] -> [a]
-  def test_reverse
-    result = ~reverse(@a)
-    expect = [5, 4, 3, 2, 1]
-
-    assert_equal(expect, result)
-  end
-
-  # intersperse       -- :: a -> [a] -> [a]
-  def test_intersperse
-    result = ~intersperse(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # transpose         -- :: [[a]] -> [[a]]
-  def test_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)
-  end
-
-  #    -- * Reducing lists (folds)
-
-  # foldl	       -- :: (a -> b -> a) -> a -> [b] -> a
-
-  def test_foldl
-    expect = 15
-
-    result = ~foldl(proc{ |x, y| x+y}, 0, @a )
-    assert_equal(expect, result)
-
-    result = ~foldl(-:+, 0, @a )
-    assert_equal(expect, result)
-  end
-
-  # foldl'	       -- :: (a -> b -> a) -> a -> [b] -> a
-  def test_foldl_
-    result = ~foldl_(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # foldl1	       -- :: (a -> a -> a) -> [a] -> a
-  def test_foldl1
-    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
-  def test_foldl1_
-    result = ~foldl1_(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # foldr             -- :: (a -> b -> b) -> b -> [a] -> b
-  def test_foldr
-    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
-  def test_foldr1
-    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]
-  def test_concat
-    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]
-  def test_concatMap
-    result = ~concatMap(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    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 = proc {|x| x>5}
-    f2 = proc {|x| x<5}
-
-    result = ~any(f1, @a)
-    expect = false
-
-    assert_equal(expect, result)
-
-    result = ~any(f2, @a)
-    expect = true
-
-    assert_equal(expect, result)
-  end
-
-  # all               -- :: (a -> Bool) -> [a] -> Bool
-  def test_all
-    result = ~all(proc {|x| x>3}, @a)
-    expect = false
-
-    assert_equal(expect, result)
-
-    result = ~all(proc {|x| x>0}, @a)
-    expect = true
-
-    assert_equal(expect, result)
-  end
-
-  # sum               -- :: (Num a) => [a] -> a
-  def test_sum
-    result = ~sum(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # product           -- :: (Num a) => [a] -> a
-  def test_product
-    result = ~product(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # maximum           -- :: (Ord a) => [a] -> a
-  def test_maximum
-    result = ~maximum(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # minimum           -- :: (Ord a) => [a] -> a
-  def test_minimum
-    result = ~minimum(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- * Building lists
-
-  #    -- ** Scans
-  # scanl             -- :: (a -> b -> a) -> a -> [b] -> [a]
-  def test_scanl
-    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]
-  def test_scanl1
-    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]
-  def test_scanr
-    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]
-  def test_scanr1
-    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])
-  def test_mapAccumL
-    result = ~mapAccumL(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # mapAccumR         -- :: (a -> b -> (a,c)) -> a -> [b] -> (a,[c])
-  def test_mapAccumR
-    result = ~mapAccumR(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- ** Infinite lists
-  # iterate           -- :: (a -> a) -> a -> [a]
-  def test_iterate
-    result = ~iterate(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # repeat            -- :: a -> [a]
-  def test_repeat
-    result = ~repeat(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # replicate         -- :: Int -> a -> [a]
-  def test_replicate
-    result = ~replicate(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # cycle             -- :: [a] -> [a]
-  def test_cycle
-    result = ~cycle(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- ** Unfolding
-  # unfoldr	       -- :: (b -> Maybe (a, b)) -> b -> [a]
-  def test_unfoldr
-    result = ~unfoldr(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- * Sublists
-
-  #    -- ** Extracting sublists
-  # take              -- :: Int -> [a] -> [a]
-  def test_take
-    result = ~take(2, @a)
-    expect = [1, 2]
-
-    assert_equal(expect, result)
-  end
-
-  # drop              -- :: Int -> [a] -> [a]
-  def test_drop
-    result = ~drop(2, @a)
-    expect = [3, 4, 5]
-
-    assert_equal(expect, result)
-  end
-
-  # splitAt           -- :: Int -> [a] -> ([a], [a])
-  def test_split_at
-    result = ~split_at(2, @a)
-    expect = [[1, 2],[3, 4, 5]]
-
-    assert_equal(expect, result)
-  end
-
-  # takeWhile         -- :: (a -> Bool) -> [a] -> [a]
-  def test_takeWhile
-    result = ~takeWhile(lambda {|x| x<4}, @a)
-    expect = [1, 2, 3]
-
-    assert_equal(expect, result)
-  end
-
-  # dropWhile         -- :: (a -> Bool) -> [a] -> [a]
-  def test_dropWhile
-    result = ~dropWhile(lambda {|x| x<4}, @a)
-    expect = [4, 5]
-
-    assert_equal(expect, result)
-  end
-
-  # span              -- :: (a -> Bool) -> [a] -> ([a], [a])
-  def test_span
-    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 = ~break_(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # group             -- :: Eq a => [a] -> [[a]]
-  def test_group
-    result = ~group(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # inits             -- :: [a] -> [[a]]
-  def test_inits
-    result = ~inits(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # tails             -- :: [a] -> [[a]]
-  def test_tails
-    result = ~tails(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  #    -- ** Predicates
-  # isPrefixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-  def test_isPrefixOf
-    result = ~isPrefixOf(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # isSuffixOf        -- :: (Eq a) => [a] -> [a] -> Bool
-  def test_isSuffixOf
-    result = ~isSuffixOf(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- * Searching lists
-
-  #    -- ** Searching by equality
-  # elem              -- :: a -> [a] -> Bool
-  def test_elem
-    result = ~elem(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # notElem           -- :: a -> [a] -> Bool
-  def test_notElem
-    result = ~notElem(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # lookup            -- :: (Eq a) => a -> [(a,b)] -> Maybe b
-  def test_lookup
-    result = ~lookup(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  #    -- ** Searching with a predicate
-  # find	       -- :: (a -> Bool) -> [a] -> Maybe a
-  def test_find
-    result = ~find(lambda {|x| x==3}, @a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # filter	       -- :: (a -> Bool) -> [a] -> [a]
-  def test_filter
-    result = ~filter(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # partition         -- :: (a -> Bool) -> [a] -> ([a], [a])
-  def test_partition
-    result = ~partition(lambda {|x| x>3}, @a)
-    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_elemIndex
-    result = ~elemIndex(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # elemIndices       -- :: (Eq a) => a -> [a] -> [Int]
-  def test_elemIndices
-    result = ~elemIndices(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  # findIndex	       -- :: (a -> Bool) -> [a] -> Maybe Int
-  def test_findIndex
-    result = ~findIndex(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # findIndices       -- :: (a -> Bool) -> [a] -> [Int]
-  def test_findIndices
-    result = ~findIndices(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- * Zipping and unzipping lists
-
-  # zip               -- :: [a] -> [b] -> [(a,b)]
-  def test_zip
-    result = ~zip(@a, @a)
-    expect = NOT_IMPLEMENTED_YET #[[1, 1], [2, 2], [3, 3], [4, 4], [5, 5] ]
-
-    assert_equal(expect, result)
-  end
-
-  # zip3  
-  def test_zip3
-    result = ~zip3(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # zip4, zip5, zip6, zip7
-  def test_zip4
-    result = ~zip4(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  # zipWith           -- :: (a -> b -> c) -> [a] -> [b] -> [c]
-  def test_zipWith
-    result = ~zipWith(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # zipWith3
-  def test_zipWith3
-    result = ~zipWith3(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # zipWith4, zipWith5, zipWith6, zipWith7
-  def test_zipWith4
-    result = ~zipWith4(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  # unzip             -- :: [(a,b)] -> ([a],[b])
-  def test_unzip
-    result = ~unzip(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # unzip3
-  def test_unzip3
-    result = ~unzip3(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # unzip4, unzip5, unzip6, unzip7
-  def test_unzip4
-    result = ~unzip4(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- * Special lists
-
-  #    -- ** Functions on strings
-  # lines	       -- :: String   -> [String]
-  def test_lines
-    result = ~lines(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # words	       -- :: String   -> [String]
-  def test_words
-    result = ~words(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # unlines           -- :: [String] -> String
-  def test_unlines
-    result = ~unlines(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # unwords           -- :: [String] -> String
-  def test_unwords
-    result = ~unwords(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- ** \"Set\" operations
-  
-  # nub               -- :: (Eq a) => [a] -> [a]
-  def test_nub
-    result = ~nub(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  # delete            -- :: (Eq a) => a -> [a] -> [a]
-  def test_delete
-    result = ~delete(3, @a)
-    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(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-  # intersect         -- :: (Eq a) => [a] -> [a] -> [a]
-  def test_intersect
-    result = ~intersect(@a)
-    expect = NOT_IMPLEMENTED_YET
-
-    assert_equal(expect, result)
-  end
-
-
-  #    -- ** Ordered lists
-
-  # 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