cohi 0.0.1

data/test/test_cohi.rb

@@ -0,0 +1,403 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "rake test" -*-
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestCohi < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def test_match_pattern?
+    f = Function.new(:foo)
+    assert_equal([], f.match_pattern?([[]], [[]]))
+    assert_equal(nil, f.match_pattern?([[]], [[1]]))
+
+    assert_equal([1], f.match_pattern?([X], [1]))
+    assert_equal(nil, f.match_pattern?([X], []))
+
+    assert_equal([1, [2, 3]], f.match_pattern?([X_XS], [[1, 2, 3]]))
+    assert_equal([1, []], f.match_pattern?([X_XS], [[1]]))
+    assert_equal(nil, f.match_pattern?([X_XS], []))
+
+    assert_equal([2], f.match_pattern?([[1, X]], [[1, 2]]))
+    assert_equal([2, [3, 4]], f.match_pattern?([[1, X, XS]], [[1, 2, 3, 4]]))
+
+    assert_equal([1, 2, [3, 4]], f.match_pattern?([X, X_XS], [1, [2, 3, 4]]))
+  end
+
+  def test_apply
+    assert_equal([4, 6, 8], map[(curry(mult, 2) * succ), [1, 2, 3]])
+    assert_equal(4, curry(mult, 2) ** succ ** 1)
+    assert_equal(4, curry(mult, 2) ** succ[1])
+  end
+  
+  def test_add
+    assert_equal(3, add[1, 2])
+  end
+  
+  def test_fun
+    assert_equal(-1, fun(:minus)[1, 2])
+  end
+
+  def test_and_or_not_otherwise
+    assert_equal(true, and_[true, true])
+    assert_equal(false, and_[false, true])
+
+    assert_equal(true, or_[true, true])
+    assert_equal(true, or_[false, true])
+
+    assert_equal(false, not_[true])
+    assert_equal(true, not_[false])
+
+    assert_equal(true, otherwise[])
+  end
+
+  def test_fst_snd
+    assert_equal(1, fst[[1, 2]])
+    assert_equal(2, snd[[1, 2]])
+  end
+
+  def test_curry
+    define(:minus2) do |x|
+      fst[x] - snd[x]
+    end
+    assert_equal(-1, minus2[[2, 3]])
+    assert_equal(-1, curry_[minus2, 2, 3])
+  end
+
+  def test_uncurry
+    assert_equal(-1, minus[2, 3])
+    assert_equal(-1, uncurry[minus, [2, 3]])
+  end
+  
+  def test_eq_etc
+    assert_equal(true, eq[1, 1])
+    assert_equal(false, eq[1, 2])
+
+    assert_equal(true, ne[1, 2])
+    assert_equal(false, ne[1, 1])
+
+    assert_equal(true, lt[1, 2])
+    assert_equal(false, lt[1, 1])
+
+    assert_equal(true, le[1, 2])
+    assert_equal(true, le[1, 1])
+    assert_equal(false, le[2, 1])
+
+    assert_equal(true, gt[2, 1])
+    assert_equal(false, gt[1, 1])
+
+    assert_equal(true, ge[2, 1])
+    assert_equal(true, ge[1, 1])
+    assert_equal(false, ge[1, 2])
+  end
+
+  def test_max_min
+    assert_equal(2, max[1, 2])
+    assert_equal(2, max[2, 1])
+
+    assert_equal(1, min[1, 2])
+    assert_equal(1, min[2, 1])
+ end
+
+  def test_succ
+    assert_equal('2', succ['1'])
+    assert_equal(2, succ[1])
+  end
+
+  def test_from_enum
+    assert_equal(1, from_enum['1'])
+  end
+
+  def test_add_minus_mult
+    assert_equal(3, add[1, 2])
+    assert_equal(-1, minus[1, 2])
+    assert_equal(6, mult[2, 3])
+  end
+
+  def test_negate_abs_signum
+    assert_equal(-1, negate[1])
+    assert_equal(1, negate[-1])
+
+    assert_equal(1, abs[1])
+    assert_equal(1, abs[-1])
+
+    assert_equal(0, signum[0])
+    assert_equal(1, signum[1])
+    assert_equal(-1, signum[-1])
+  end
+
+  def test_to_rational
+    assert_kind_of(Rational, to_rational[1])
+    assert_equal(1, to_rational[1])
+  end
+
+  def test_quot_div_rem_mod
+    assert_equal(2, quot[5, 2])
+    assert_equal(2, div[5, 2])
+    assert_equal(-2, quot[-5, 2])
+    assert_equal(-3, div[-5, 2])
+
+    assert_equal(2, rem[5, 3])
+    assert_equal(2, mod[5, 3])
+    assert_equal(-2, rem[-5, 3])
+    assert_equal(1, mod[-5, 3])
+
+    assert_equal([2, 1], quot_rem[5, 2])
+    assert_equal([2, 1], div_mod[5, 2])
+    assert_equal([-2, -1], quot_rem[-5, 2])
+    assert_equal([-3, 1], div_mod[-5, 2])
+  end
+
+  def test_to_integer
+    assert_equal(1, to_integer['1'])
+  end
+
+  def test_fractional
+    assert_equal(Rational(2, 1), divr[Rational(8, 2), Rational(2, 1)])
+
+    assert_equal(Rational(5, 3), recip[Rational(3, 5)])
+  end
+
+  def test_math
+    assert_equal(Math::PI, pi[])
+    assert_equal(Math::exp(1), exp[1])
+    assert_equal(Math::log(1), log[1])
+    assert_equal(Math::sqrt(1), sqrt[1])
+    assert_equal(8, power[2, 3])
+    assert_equal(2, log_base[3, 9])
+    assert_equal(Math::sin(1), sin[1])
+    assert_equal(Math::cos(1), cos[1])
+    assert_equal(Math::tan(1), tan[1])
+    assert_equal(Math::asin(1), asin[1])
+    assert_equal(Math::acos(1), acos[1])
+    assert_equal(Math::atan(1), atan[1])
+    assert_equal(Math::sinh(1), sinh[1])
+    assert_equal(Math::cosh(1), cosh[1])
+    assert_equal(Math::tanh(1), tanh[1])
+    assert_equal(Math::asinh(1), asinh[1])
+    assert_equal(Math::acosh(1), acosh[1])
+    assert_equal(Math::atanh(1), atanh[1])
+  end
+
+  def test_truncate
+    assert_equal(1, truncate[1.9])
+    assert_equal(1, truncate[1.1])
+    assert_equal(-1, truncate[-1.1])
+    assert_equal(-1, truncate[-1.9])
+
+    assert_equal(2, round[1.9])
+    assert_equal(1, round[1.1])
+    assert_equal(-1, round[-1.1])
+    assert_equal(-2, round[-1.9])
+
+    assert_equal(2, ceil[1.9])
+    assert_equal(2, ceil[1.1])
+    assert_equal(-1, ceil[-1.1])
+    assert_equal(-1, ceil[-1.9])
+
+    assert_equal(1, floor[1.9])
+    assert_equal(1, floor[1.1])
+    assert_equal(-2, floor[-1.1])
+    assert_equal(-2, floor[-1.9])
+  end
+
+  def test_atan2
+    assert_equal(Math.atan2(1, 2), atan2[1, 2])
+  end  
+
+  def test_subtract
+    assert_equal(-1, subtract[1, 2])
+  end
+
+  def test_even_odd
+    assert_equal(true, even[2])
+    assert_equal(false, even[1])
+    assert_equal(false, odd[2])
+    assert_equal(true, odd[1])
+  end
+
+  def test_gcd_lcm
+    assert_equal(8, gcd[32, 24])
+    assert_equal(8, gcd[24, 32])
+
+    assert_equal(24, lcm[12, 8])
+    assert_equal(24, lcm[8, 12])
+  end
+
+  def test_id_const_as_type_of
+    assert_equal(1, id_[1])
+    assert_equal(1, const[1, 2])
+    assert_equal(1, as_type_of[1, 2])
+  end
+
+  def test_flip
+    assert_equal(-1, flip[minus, 2, 1])
+  end
+
+  def test_until
+    assert_equal(3, until_[lambda {|i| i == 3 }, lambda {|i| i + 1 }, 0])
+  end
+
+  def test_map
+    assert_equal([11, 12, 13], map[curry(add, 10), [1, 2, 3]])
+    assert_equal([], map[curry(add, 10), []])
+  end
+
+  def test_append
+    assert_equal([1, 2, 3, 4, 5, 6], append[[1, 2, 3], [4, 5, 6]])
+  end
+
+  def test_filter
+    assert_equal([1, 2, 3], filter[lambda {|a| a > 0 }, [1, 0, 2, -4, 3, -5]])
+    assert_equal([], filter[lambda {|a| a > 0 }, []])
+  end
+
+  def test_head
+    assert_equal(1, head[[1, 2, 3]])
+  end
+
+  def test_last
+    assert_equal(3, last[[1, 2, 3]])
+  end
+
+  def test_tail
+    assert_equal([2, 3], tail[[1, 2, 3]])
+  end
+  
+  def test_init
+    assert_equal([1, 2], init[[1, 2, 3]])
+  end
+
+  def test_null
+    assert_equal(true, null[[]])
+    assert_equal(false, null[[1]])
+  end
+
+  def test_length
+    assert_equal(3, length[[1, 2, 3]])
+  end
+
+  def test_at
+    assert_equal(3, at[[1, 2, 3], 2])
+  end
+
+  def test_reverse
+    assert_equal([3, 2, 1], reverse[[1, 2, 3]])
+  end
+
+  def test_foldl
+    assert_equal(16, foldl[add, 10, [1, 2, 3]])
+    assert_equal(6, foldl1[add, [1, 2, 3]])
+  end
+
+  def test_foldr
+    assert_equal(16, foldr[add, 10, [1, 2, 3]])
+    assert_equal(6, foldr1[add, [1, 2, 3]])
+  end
+
+  def test_anda_ora
+    assert_equal(true, anda[[true, true, true]])
+    assert_equal(false, anda[[true, false, true]])
+
+    assert_equal(true, ora[[false, true, false]])
+    assert_equal(false, ora[[false, false, false]])
+  end
+
+  def test_any_all
+    assert_equal(true, any[lambda {|a| a > 0}, [-1, 0, 1]])    
+    assert_equal(false, any[lambda {|a| a > 2}, [-1, 0, 1]])    
+
+    assert_equal(false, all[lambda {|a| a > 0}, [-1, 0, 1]])    
+    assert_equal(true, all[lambda {|a| a > -2}, [-1, 0, 1]])    
+  end
+
+  def test_sum_product
+    assert_equal(6, sum[[1, 2, 3]])
+    assert_equal(24, product[[1, 2, 3, 4]])
+  end
+
+  def test_concat
+    assert_equal([1, 2, 3, 4, 5, 6], concat[[[1, 2, 3], [4, 5], [6]]])    
+  end
+
+  def test_concat_map
+    assert_equal([2, 3, 4], concat_map[lambda {|a| [a + 1] }, [1, 2, 3]])
+  end
+
+  def test_maximum
+    assert_equal(5, maximum[[1, 3, 5, 2, 4]])
+    assert_equal(1, minimum[[1, 3, 5, 2, 4]])
+  end
+
+  def test_scan
+    assert_equal([10, 11, 13, 16], scanl[add, 10, [1, 2, 3]])
+    assert_equal([1, 3, 6], scanl1[add, [1, 2, 3]])
+
+    assert_equal([16, 15, 13, 10], scanr[add, 10, [1, 2, 3]])
+    assert_equal([6, 5, 3], scanr1[add, [1, 2, 3]])
+  end
+
+  def test_replicate
+    assert_equal([1, 1, 1], replicate[3, 1])    
+  end
+
+  def test_take_drop_split_at
+    assert_equal([1, 2, 3], take[3, [1, 2, 3, 4, 5]])    
+    assert_equal([4, 5], drop[3, [1, 2, 3, 4, 5]])    
+    assert_equal([[1, 2, 3], [4, 5]], split_at[3, [1, 2, 3, 4, 5]])    
+  end
+
+  def test_take_while_drop_while
+    assert_equal([1, 2, 3], take_while[lambda {|a| a < 4 }, [1, 2, 3, 4, 5]])
+    assert_equal([4, 5], drop_while[lambda {|a| a < 4 }, [1, 2, 3, 4, 5]])
+  end
+
+  def test_span_break
+    assert_equal([[1, 2, 3], [4, 5]], span[lambda {|a| a < 4 }, [1, 2, 3, 4, 5]])
+    assert_equal([[1, 2, 3], [4, 5]], break_[lambda {|a| a >= 4 }, [1, 2, 3, 4, 5]])
+  end
+
+  def test_elem_not_elem
+    assert_equal(true, elem[1, [1, 2, 3, 4, 5]])
+    assert_equal(false, elem[0, [1, 2, 3, 4, 5]])
+
+    assert_equal(false, not_elem[1, [1, 2, 3, 4, 5]])
+    assert_equal(true, not_elem[0, [1, 2, 3, 4, 5]])
+  end
+
+  def test_zip_zip3
+    assert_equal([[1, 4], [2, 5], [3, 6]], zip[[1, 2, 3], [4, 5, 6]])
+    assert_equal([[1, 4, 7], [2, 5, 8], [3, 6, 9]], 
+      zip3[[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+  end
+
+  def test_zip_with_zip_with3
+    assert_equal([5, 7, 9], zip_with[add, [1, 2, 3], [4, 5, 6]])
+    assert_equal([12, 15, 18], 
+      zip_with3[lambda {|a, b, c| a + b + c }, 
+        [1, 2, 3], [4, 5, 6], [7, 8, 9]])
+  end
+
+  def test_unzip_unzip3
+    assert_equal([[1, 2, 3], [4, 5, 6]], unzip[[[1, 4], [2, 5], [3, 6]]])
+    assert_equal([[1, 2, 3], [4, 5, 6], [7, 8, 9]],
+      unzip3[[[1, 4, 7], [2, 5, 8], [3, 6, 9]]])
+  end
+
+  def test_lines_words_unlines_unwords
+    assert_equal(['aaa', 'bbb', 'ccc'], lines["aaa\nbbb\nccc\n"])
+    assert_equal(['aaa', 'bbb', 'ccc'], words["aaa bbb  ccc"])
+
+    assert_equal("aaa\nbbb\nccc\n", unlines[['aaa', 'bbb', 'ccc']])
+    assert_equal('', unlines[[]])
+
+    assert_equal("aaa bbb ccc", unwords[['aaa', 'bbb', 'ccc']])
+    assert_equal('', unwords[[]])
+  end
+
+  def test_show
+    assert_equal('[1, 2, 3]', show[[1, 2, 3]])
+  end  
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/cohi'
+require File.dirname(__FILE__) + '/../lib/cohi/prelude.rb'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: cohi
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-07-01 00:00:00 +09:00
+summary: Cohi is a tiny library for aiding functional programming.
+require_paths: 
+- lib
+email: tanaka.shinya@gmail.com
+homepage: http://cohi.rubyforge.org
+rubyforge_project: cohi
+description: Cohi is a tiny library for aiding functional programming.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- TANAKA Shin-ya(id:ha-tan)
+files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+- Rakefile
+- example/fact.rb
+- example/fib.rb
+- lib/cohi.rb
+- lib/cohi/prelude.rb
+- lib/cohi/version.rb
+- setup.rb
+- test/test_cohi.rb
+- test/test_helper.rb
+test_files: 
+- test/test_cohi.rb
+- test/test_helper.rb
+rdoc_options: 
+- --main
+- README.txt
+extra_rdoc_files: 
+- History.txt
+- License.txt
+- Manifest.txt
+- README.txt
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+