cohi 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.0.1 2007-07-01
+
+  * �ŏ��̃����[�X�B
+
+  * Prelude�̎�v�Ȋ֐��������B

data/License.txt

@@ -0,0 +1 @@
+Ruby's License

data/Manifest.txt

@@ -0,0 +1,13 @@
+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

data/README.txt

@@ -0,0 +1,39 @@
+
+    Cohi - �֐��^�v���O���~���O�x�����C�u����
+   ===========================================
+
+������ĉ��H
+-----------
+  Ruby�Ŋ֐��^�v���O���~���O�����邽�߂֗̕����C�u�����ł��B
+  Haskell�̉e���𑽕��Ɏ󂯂Ă��܂��B
+
+  �l��Haskell(��Ruby)��׋����邽�߂ɍ��܂����B�Ƃ�����
+  Ruby�łǂ��܂�Haskell�ɋߕt���邩�Ȃ��Ǝv���Ȃ�����܂����B
+  ���\�͓�̎��ł��B
+
+  Cohi�̌ꌹ�͈ȉ��ł��B
+    lambda �� lamb �� ���Ђ‚� �� Cohi
+
+  �ŋߗ��s���MDD(Mascot Driven Development)���ӎ����Ȃ��疽�����܂����B
+  ���A�}�X�R�b�g�͂܂�����܂���B��W���ł��B
+
+�C���X�g�[��
+------------
+  Gem�ŃC���X�g�[�����Ă��������B
+
+    $ gem install cohi
+
+�T���v��
+--------
+  example�f�B���N�g���������������B
+
+�T�|�[�g
+--------
+  ��������܂����牺�L�܂ł��肢���܂��B
+    <tanaka.shinya@gmail.com>
+
+�ӎ�
+----
+  ���̃��C�u�����́A�т킱�J�����h(2007/06/30�`2007/07/01)��
+  �����ɂ܂����ĊJ�����܂����B������yhara���܁A��������������
+  �Q���҂̊F���܂Ɋ��ӂ��܂��B

data/Rakefile

@@ -0,0 +1,123 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/contrib/rubyforgepublisher'
+require 'fileutils'
+require 'hoe'
+
+include FileUtils
+require File.join(File.dirname(__FILE__), 'lib', 'cohi', 'version')
+
+AUTHOR = 'TANAKA Shin-ya(id:ha-tan)'  # can also be an array of Authors
+EMAIL = "tanaka.shinya@gmail.com"
+DESCRIPTION = "Cohi is a tiny library for aiding functional programming."
+GEM_NAME = 'cohi' # what ppl will type to install your gem
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}"
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  @rubyforge_username ||= @config["username"]
+end
+
+RUBYFORGE_PROJECT = 'cohi' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "cohi"
+REV = nil 
+# UNCOMMENT IF REQUIRED: 
+# REV = `svn info`.each {|line| if line =~ /^Revision:/ then k,v = line.split(': '); break v.chomp; else next; end} rescue nil
+VERS = Cohi::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'cohi documentation',
+    "--opname", "index.html",
+    "--line-numbers", 
+    "--main", "README",
+    "--inline-source"]
+
+class Hoe
+  def extra_deps 
+    @extra_deps.reject { |x| Array(x).first == 'hoe' } 
+  end 
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.author = AUTHOR 
+  p.description = DESCRIPTION
+  p.email = EMAIL
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= CLEAN  #An array of file patterns to delete on clean.
+  
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  #p.extra_deps = []     # An array of rubygem dependencies [name, version], e.g. [ ['active_support', '>= 1.3.1'] ]
+  #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+end
+
+CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+
+desc 'Generate website files'
+task :website_generate do
+  Dir['website/**/*.txt'].each do |txt|
+    sh %{ ruby scripts/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
+  end
+end
+
+desc 'Upload website files to rubyforge'
+task :website_upload do
+  host = "#{rubyforge_username}@rubyforge.org"
+  remote_dir = "/var/www/gforge-projects/#{PATH}/"
+  local_dir = 'website'
+  sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
+end
+
+desc 'Generate and upload website files'
+task :website => [:website_generate, :website_upload, :publish_docs]
+
+desc 'Release the website and new gem version'
+task :deploy => [:check_version, :website, :release] do
+  puts "Remember to create SVN tag:"
+  puts "svn copy svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/trunk " +
+    "svn+ssh://#{rubyforge_username}@rubyforge.org/var/svn/#{PATH}/tags/REL-#{VERS} "
+  puts "Suggested comment:"
+  puts "Tagging release #{CHANGES}"
+end
+
+desc 'Runs tasks website_generate and install_gem as a local deployment of the gem'
+task :local_deploy => [:website_generate, :install_gem]
+
+task :check_version do
+  unless ENV['VERSION']
+    puts 'Must pass a VERSION=x.y.z release version'
+    exit
+  end
+  unless ENV['VERSION'] == VERS
+    puts "Please update your version.rb to match the release version, currently #{VERS}"
+    exit
+  end
+end
+
+

data/example/fact.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "ruby fact.rb" -*-
+
+$LOAD_PATH << '../lib'
+require 'cohi'
+require 'cohi/prelude'
+
+include Cohi
+
+# (1)
+define(:fact1) do |n|
+  if n == 0
+    1
+  else
+    n * fact1[n - 1]
+  end
+end
+p fact1[5] # => 120
+
+# (2)
+define(:fact2, [0]) do 
+  1
+end
+define(:fact2, [X]) do |n|
+  n * fact2[n - 1]
+end
+p fact2[5] # => 120
+
+# (3)
+define(:fact3) do |n|
+  foldr[mult, 1, (1 .. n).to_a]
+end
+p fact3[5] # => 120
+
+# (4)
+define(:fact4) do |n|
+  foldl1[mult, (1 .. n).to_a]
+end
+p fact4[5] # => 120
+
+# (5)
+define(:fact5) do |n|
+  last[scanl1[mult, (1 .. n).to_a]]
+end
+p fact5[5] # => 120

data/example/fib.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "ruby fib.rb" -*-
+
+$LOAD_PATH << '../lib'
+require 'cohi'
+require 'cohi/prelude'
+require 'benchmark'
+
+include Cohi
+
+define(:fib, [0]) { 0 }
+define(:fib, [1]) { 1 }
+define(:fib, [2]) { 1 }
+define(:fib) {|n| fib[n - 1] + fib[n - 2] }
+
+# ref. http://kerolin.jspeed.jp/Computer/Linux/fib060810.html
+define(:fib_step, [[X, X]]) do |u, v|
+  [v, u + v]
+end
+
+define(:fib_pair, [0]) do
+  [0, 1]
+end
+define(:fib_pair, [X]) do |n|
+  fib_step[fib_pair[n - 1]]
+end
+
+define(:fast_fib) do |n|
+  fst[fib_pair[n]]
+end
+
+n = 20
+Benchmark.bm do |x|
+  x.report { fib[n] }
+  x.report { fast_fib[n] }
+end
+#       user     system      total        real
+#   0.510000   0.000000   0.510000 (  0.591000)
+#   0.000000   0.000000   0.000000 (  0.000000)
+
+
+

data/lib/cohi.rb

@@ -0,0 +1,95 @@
+module Cohi
+  FUNCS = {}
+
+  X = Object.new
+  XS = Object.new
+  X_XS = Object.new
+
+  class Function
+    def initialize(sym)
+      @sym = sym
+      @func = []
+    end
+
+    def add(pat, &f)
+      @func.push([pat, f])
+    end
+
+    def [](*xs)
+      @func.each do |func|
+        pat, f = *func
+        xs2 = match_pattern?(pat, xs)
+        return f[*xs2] if xs2
+      end
+      raise(ArgumentError, "no match pattern. `#{@sym}' #{xs.inspect}")
+    end
+
+    def match_pattern?(pat, xs)
+      return xs unless pat 
+      return nil if not pat.include?(XS) and pat.size != xs.size
+      rs = []
+      pat.each_with_index do |pt, i|
+        x = xs[i]
+        case pt
+        when Array
+          xs3 = match_pattern?(pt, x)
+          return nil unless xs3
+          rs += xs3
+        when X
+          rs << x
+          next
+        when XS
+          rs << [x, *xs[i + 1 .. -1]]
+          xs = []
+          next
+        when X_XS
+          y, *ys = *x
+          rs << y
+          rs << ys
+          next
+        when x
+          next
+        else
+          return nil
+        end
+      end
+      rs
+    end
+
+    def *(f)
+      lambda {|*xs| self[f[*xs]] }
+    end
+
+    def **(*xs)
+      self[*xs]
+    end
+  end
+
+  def define(sym, pat = nil, &f)
+    FUNCS[sym] ||= Function.new(sym)
+    FUNCS[sym].add(pat, &f)
+    unless self.class.method_defined?(sym) 
+      self.class.module_eval("def #{sym}; fun(:#{sym}); end")
+    end
+  end
+
+  def curry(f, *vs)
+    lambda {|v| f[*(vs + [v])] }
+  end
+
+  def fun(sym)
+    FUNCS[sym]
+  end
+end
+
+class Proc
+  def *(f)
+    lambda {|*xs| self[f[*xs]] }
+  end
+
+  def **(xs)
+    self[xs]
+  end
+end
+
+require 'cohi/version'

data/lib/cohi/prelude.rb

@@ -0,0 +1,1011 @@
+require 'rational'
+require 'pathname'
+
+include Cohi
+
+# The Meaning of Mark
+#   F ... Finished
+#   N ... Not finished
+#   I ... Impossible
+
+# data Bool = False | True
+# ###F### (&&) :: Bool -> Bool -> Bool
+define(:and_) do |a, b|
+  a and b
+end
+
+# ###F### (||) :: Bool -> Bool -> Bool
+define(:or_) do |a, b|
+  a or b
+end
+
+# ###F### not :: Bool -> Bool
+define(:not_) do |x|
+  not x
+end
+
+# ###F### otherwise :: Bool
+define(:otherwise) do
+  true
+end
+
+# data Maybe a = Nothing | Just a
+# ###I### maybe :: b -> (a -> b) -> Maybe a -> b
+
+# data Either a b = Left a | Right b
+# ###I### either :: (a -> c) -> (b -> c) -> Either a b -> c
+
+# data Ordering = LT | EQ | GT
+# data Char
+# type String = [Char]
+
+# ###F### fst :: (a, b) -> a
+define(:fst) do |x|
+  x.first
+end
+
+# ###F### snd :: (a, b) -> b
+define(:snd) do |x|
+  x.last
+end
+
+# ###F### curry :: ((a, b) -> c) -> a -> b -> c
+define(:curry_) do |f, x, y|
+  f[[x, y]]
+end
+
+# ###F### uncurry :: (a -> b -> c) -> (a, b) -> c
+define(:uncurry) do |f, x|
+  f[fst[x], snd[x]]
+end
+
+# class Eq a where
+# ###F### (==) :: a -> a -> Bool
+define(:eq) do |a, b|
+  a == b
+end
+
+# ###F### (/=) :: a -> a -> Bool
+define(:ne) do |a, b|
+  not_[eq[a, b]]
+end
+
+# class Eq a => Ord a where
+# ###N### compare :: a -> a -> Ordering
+# ###F### (<) :: a -> a -> Bool
+define(:lt) do |a, b|
+  a < b
+end
+
+# ###F### (<=) :: a -> a -> Bool
+define(:le) do |a, b|
+  a <= b
+end
+
+# ###F### (>) :: a -> a -> Bool
+define(:gt) do |a, b|
+  a > b
+end
+
+# ###F### (>=) :: a -> a -> Bool
+define(:ge) do |a, b|
+  a >= b
+end
+
+# ###F### max :: a -> a -> a
+define(:max) do |a, b|
+  gt[a, b] ? a : b
+end
+
+# ###F### min :: a -> a -> a
+define(:min) do |a, b|
+  lt[a, b] ? a : b
+end
+
+# class Enum a where
+# ###F### succ :: a -> a
+define(:succ) do |x|
+  x.succ
+end
+
+# ###I### pred :: a -> a
+#   not exist suitable method in ruby...
+
+# ###I### toEnum :: Int -> a
+#   not exist suitable method in ruby...
+
+# ###F### fromEnum :: a -> Int
+define(:from_enum) do |x|
+  x.to_i
+end
+
+# ###F### enumFrom :: a -> [a]
+define(:from_enum) do |x|
+  x.to_i
+end
+
+# ###I### enumFromThen :: a -> a -> [a]
+# ###I### enumFromTo :: a -> a -> [a]
+# ###I### enumFromThenTo :: a -> a -> a -> [a]
+#   not exist suitable method in ruby...
+
+# class Bounded a where
+# ###I### minBound :: a
+# ###I### maxBound :: a
+#   not exist suitable method in ruby...
+
+# data Int
+# data Integer
+# data Float
+# data Double
+# type Rational = Ratio Integer
+# class (Eq a, Show a) => Num a where
+# ###F### (+) :: a -> a -> a
+define(:add) do |a, b|
+  a + b
+end
+
+# ###F### (-) :: a -> a -> a
+define(:minus) do |a, b|
+  a - b
+end
+
+# ###F### (*) :: a -> a -> a
+define(:mult) do |a, b|
+  a * b
+end
+
+# ###F### negate :: a -> a
+define(:negate) do |a|
+  -a
+end
+
+# ###F### abs :: a -> a
+define(:abs) do |a|
+  gt[a, 0] ? a : negate[a]
+end
+
+# ###F### signum :: a -> a
+define(:signum) do |a|
+  if eq[a, 0]
+    0
+  else
+    gt[a, 0] ? 1 : -1
+  end
+end
+
+# ###I### fromInteger :: Integer -> a
+#   not exist suitable method in ruby...
+
+# class (Num a, Ord a) => Real a where
+# ###F### toRational :: a -> Rational
+define(:to_rational) do |x|
+  x.to_r
+end
+
+# class (Real a, Enum a) => Integral a where
+# ###F### quot :: a -> a -> a
+define(:quot) do |a, b|
+  if ge[a, 0]
+    a / b
+  else
+    negate[a.abs / b]
+  end
+end
+
+# ###F### rem :: a -> a -> a
+define(:rem) do |a, b|
+  if ge[a, 0]
+    a % b
+  else
+    negate[a.abs % b]
+  end
+end
+
+# ###F### div :: a -> a -> a
+define(:div) do |a, b|
+  a / b
+end
+
+# ###F### mod :: a -> a -> a
+define(:mod) do |a, b|
+  a % b
+end
+
+# ###F### quotRem :: a -> a -> (a, a)
+define(:quot_rem) do |a, b|
+  [quot[a, b], rem[a, b]]
+end
+
+# ###F### divMod :: a -> a -> (a, a)
+define(:div_mod) do |a, b|
+  a.divmod b
+end
+
+# ###F### toInteger :: a -> Integer
+define(:to_integer) do |x|
+  x.to_i
+end
+
+# class Num a => Fractional a where
+# ###F### (/) :: a -> a -> a
+define(:divr) do |a, b|
+  a / b # fractional division
+end
+
+# ###F### recip :: a -> a
+define(:recip) do |a|
+  Rational(a.denominator, a.numerator)
+end
+
+# fromRational :: Rational -> a
+# class Fractional a => Floating a where
+# ###F### pi :: a
+define(:pi) do
+  Math::PI
+end
+
+# ###F### exp :: a -> a
+define(:exp) do |a|
+  Math::exp(a)
+end
+
+# ###F### log :: a -> a
+define(:log) do |a|
+  Math::log(a)
+end
+
+# ###F### sqrt :: a -> a
+define(:sqrt) do |a|
+  Math::sqrt(a)
+end
+
+# ###F### (**) :: a -> a -> a
+define(:power) do |a, b|
+  a ** b
+end
+
+# ###F### logBase :: a -> a -> a
+define(:log_base) do |a, b|
+  Math::log(b) / Math::log(a)
+end
+
+# ###F### sin :: a -> a
+define(:sin) do |a|
+  Math::sin(a)
+end
+
+# ###F### cos :: a -> a
+define(:cos) do |a|
+  Math::cos(a)
+end
+
+# ###F### tan :: a -> a
+define(:tan) do |a|
+  Math::tan(a)
+end
+
+# ###F### asin :: a -> a
+define(:asin) do |a|
+  Math::asin(a)
+end
+
+# ###F### acos :: a -> a
+define(:acos) do |a|
+  Math::acos(a)
+end
+
+# ###F### atan :: a -> a
+define(:atan) do |a|
+  Math::atan(a)
+end
+
+# ###F### sinh :: a -> a
+define(:sinh) do |a|
+  Math::sinh(a)
+end
+
+# ###F### cosh :: a -> a
+define(:cosh) do |a|
+  Math::cosh(a)
+end
+
+# ###F### tanh :: a -> a
+define(:tanh) do |a|
+  Math::tanh(a)
+end
+
+# ###F### asinh :: a -> a
+define(:asinh) do |a|
+  Math::asinh(a)
+end
+
+# ###F### acosh :: a -> a
+define(:acosh) do |a|
+  Math::acosh(a)
+end
+
+# ###F### atanh :: a -> a
+define(:atanh) do |a|
+  Math::atanh(a)
+end
+
+# class (Real a, Fractional a) => RealFrac a where
+# ###I### properFraction :: Integral b => a -> (b, a)
+#   not exist suitable method in ruby...
+
+# ###F### truncate :: Integral b => a -> b
+define(:truncate) do |a|
+  a.truncate
+end
+
+# ###N### round :: Integral b => a -> b
+define(:round) do |a|
+  a.round
+end
+
+# ###N### ceiling :: Integral b => a -> b
+define(:ceil) do |a|
+  a.ceil
+end
+
+# ###N### floor :: Integral b => a -> b
+define(:floor) do |a|
+  a.floor
+end
+
+# class (RealFrac a, Floating a) => RealFloat
+# ###I### floatRadix :: a -> Integer
+# ###I### floatDigits :: a -> Int
+# ###I### floatRange :: a -> (Int, Int)
+# ###I### decodeFloat :: a -> (Integer, Int)
+# ###I### encodeFloat :: Integer -> Int -> a
+# ###I### exponent :: a -> Int
+# ###I### significand :: a -> a
+# ###I### scaleFloat :: Int -> a -> a
+# ###I### isNaN :: a -> Bool
+# ###I### isInfinite :: a -> Bool
+# ###I### isDenormalized :: a -> Bool
+# ###I### isNegativeZero :: a -> Bool
+# ###I### isIEEE :: a -> Bool
+#   not exist suitable method in ruby...
+
+# ###I### atan2 :: a -> a -> a
+define(:atan2) do |a, b|
+  Math::atan2(a, b)
+end
+
+# ###F### subtract :: Num a => a -> a -> a
+define(:subtract) do |a, b|
+  a - b
+end
+
+# ###F### even :: Integral a => a -> Bool
+define(:even) do |a|
+  mod[a, 2] == 0
+end
+
+# ###F### odd :: Integral a => a -> Bool
+define(:odd) do |a|
+  mod[a, 2] == 1
+end
+
+# ###F### gcd :: Integral a => a -> a -> a
+define(:gcd, [X, 0]) do |a|
+  a
+end
+define(:gcd, [X, X]) do |a, b|
+  gcd[b, mod[a, b]]
+end
+
+# ###F### lcm :: Integral a => a -> a -> a
+define(:lcm) do |a, b|
+  a * b / gcd[a, b]
+end
+
+# ###I### (^) :: (Num a, Integral b) => a -> b -> a
+# ###I### (^^) :: (Fractional a, Integral b) => a -> b -> a
+# ###I### fromIntegral :: (Integral a, Num b) => a -> b
+# ###I### realToFrac :: (Real a, Fractional b) => a -> b
+#   not exist suitable method in ruby...
+
+# class Monad m where
+# ###I### (>>=) :: forall a b . m a -> (a -> m b) -> m b
+# ###I### (>>) :: forall a b . m a -> m b -> m b
+# ###I### return :: a -> m a
+#   not exist suitable method in ruby...
+
+# fail :: String -> m a
+define(:fail) do |a|
+  raise("### Exception: user error (#{a})")
+end
+
+# class Functor f where
+# ###I### fmap :: (a -> b) -> f a -> f b
+# ###I### mapM :: Monad m => (a -> m b) -> [a] -> m [b]
+# ###I### mapM_ :: Monad m => (a -> m b) -> [a] -> m ()
+# ###I### sequence :: Monad m => [m a] -> m [a]
+# ###I### sequence_ :: Monad m => [m a] -> m ()
+# ###I### (=<<) :: Monad m => (a -> m b) -> m a -> m b
+#   not exist suitable method in ruby...
+
+# ###F### id :: a -> a
+define(:id_) do |a|
+  a
+end
+
+# ###F### const :: a -> b -> a
+define(:const) do |a, b|
+  a
+end
+
+# ###I### (.) :: (b -> c) -> (a -> b) -> a -> c
+#   not exist suitable method in ruby...
+
+# ###F### flip :: (a -> b -> c) -> b -> a -> c
+define(:flip) do |f, b, a|
+  f[a, b]
+end
+
+# ###I### ($) :: (a -> b) -> a -> b
+#   not exist suitable method in ruby...
+
+# ###F### until :: (a -> Bool) -> (a -> a) -> a -> a
+define(:until_) do |pr, f, x|
+  if pr[x]
+    x
+  else
+    until_[pr, f, f[x]]
+  end
+end
+
+# ###F### asTypeOf :: a -> a -> a
+define(:as_type_of) do |a, b|
+  const[a, b]
+end
+
+# ###F### error :: String -> a
+define(:error) do |a|
+  raise("### Exception: #{a}")
+end
+
+# ###F### undefined :: a
+define(:undefined) do |a|
+  error['Prelude.undefined']
+end
+
+# ###I### seq :: a -> b -> b
+# ###I### ($!) :: (a -> b) -> a -> b
+#   not exist suitable method in ruby...
+
+# ###F### map :: (a -> b) -> [a] -> [b]
+define(:map, [X, []]) do
+  []
+end
+define(:map, [X, X_XS]) do |f, x, xs|
+  [f[x]] + map[f, xs]
+end
+
+# ###F### (++) :: [a] -> [a] -> [a]
+define(:append) do |a, b|
+  a + b
+end
+
+# ###F### filter :: (a -> Bool) -> [a] -> [a]
+define(:filter, [X, []]) do
+  []
+end
+define(:filter, [X, X_XS]) do |f, x, xs|
+  if f[x]
+    [x] + filter[f, xs]
+  else
+    filter[f, xs]
+  end
+end
+
+# ###F### head :: [a] -> a
+define(:head, [[]]) do
+  error['Prelude.head: empty list']
+end
+define(:head, [X_XS]) do |x, xs|
+  x
+end
+
+# ###F### last :: [a] -> a
+define(:last, [[]]) do
+  error['Prelude.last: empty list']
+end
+define(:last, [[X]]) do |x|
+  x
+end
+define(:last, [X_XS]) do |x, xs|
+  last[xs]
+end
+
+# ###F### tail :: [a] -> [a]
+define(:tail, [[]]) do
+  error['Prelude.tail: empty list']
+end
+define(:tail, [X_XS]) do |x, xs|
+  xs
+end
+
+# ###F### init :: [a] -> [a]
+define(:init, [[]]) do
+  error['Prelude.init: empty list']
+end
+define(:init, [[X]]) do |x|
+  []
+end
+define(:init, [X_XS]) do |x, xs|
+  [x] + init[xs]
+end
+
+# ###F### null :: [a] -> Bool
+define(:null, [[]]) do
+  true
+end
+define(:null, [X]) do |x|
+  false
+end
+
+# ###F### length :: [a] -> Int
+define(:length) do |a|
+  length2[a, 0]
+end
+
+define(:length2, [[], X]) do |a|
+  a
+end
+define(:length2, [X_XS, X]) do |x, xs, a|
+  length2[xs, a + 1]
+end
+
+# ###F### (!!) :: [a] -> Int -> a
+define(:at) do |a, i|
+  a[i]
+end
+
+# ###F### reverse :: [a] -> [a]
+define(:reverse) do |a|
+  reverse2[a, []]
+end
+
+define(:reverse2, [[], X]) do |a|
+  a
+end
+define(:reverse2, [X_XS, X]) do |x, xs, a|
+  reverse2[xs, [x] + a]
+end
+
+# ###F### foldl :: (a -> b -> a) -> a -> [b] -> a
+define(:foldl, [X, X, []]) do |f, z|
+  z
+end
+define(:foldl, [X, X, X_XS]) do |f, z, x, xs|
+  foldl[f, f[z, x], xs]
+end
+
+# ###F### foldl1 :: (a -> a -> a) -> [a] -> a
+define(:foldl1, [X, []]) do |f|
+  error['Prelude.foldl1: empty list']
+end
+define(:foldl1, [X, X_XS]) do |f, x, xs|
+  foldl[f, x, xs]
+end
+
+# ###F### foldr :: (a -> b -> b) -> b -> [a] -> b
+define(:foldr, [X, X, []]) do |f, z|
+  z
+end
+define(:foldr, [X, X, X_XS]) do |f, z, x, xs|
+  f[x, foldr[f, z, xs]]
+end
+
+# ###F### foldr1 :: (a -> a -> a) -> [a] -> a
+define(:foldr1, [X, []]) do |f|
+  error['Prelude.foldr1: empty list']
+end
+define(:foldr1, [X, [X]]) do |f, x|
+  x
+end
+define(:foldr1, [X, X_XS]) do |f, x, xs|
+  f[x, foldr1[f, xs]]
+end
+
+# ###F### and :: [Bool] -> Bool
+define(:anda, [[]]) do
+  true
+end
+define(:anda, [X_XS]) do |x, xs|
+  and_[x, anda[xs]]
+end
+
+# ###F### or :: [Bool] -> Bool
+define(:ora, [[]]) do
+  false
+end
+define(:ora, [X_XS]) do |x, xs|
+  or_[x, ora[xs]]
+end
+
+# ###F### any :: (a -> Bool) -> [a] -> Bool
+define(:any) do |pr, xs|
+  ora[map[pr, xs]]
+end
+
+# ###F### all :: (a -> Bool) -> [a] -> Bool
+define(:all) do |pr, xs|
+  anda[map[pr, xs]]
+end
+
+# ###F### sum :: Num a => [a] -> a
+define(:sum) do |xs|
+  foldl[add, 0, xs]
+end
+
+# ###F### product :: Num a => [a] -> a
+define(:product) do |xs|
+  foldl[mult, 1, xs]
+end
+
+# ###F### concat :: [[a]] -> [a]
+define(:concat) do |xs|
+  foldr[append, [], xs]
+end
+
+# ###F### concatMap :: (a -> [b]) -> [a] -> [b]
+define(:concat_map) do |f, xs|
+  concat[map[f, xs]]
+end
+
+# ###F### maximum :: Ord a => [a] -> a
+define(:maximum, [[]]) do
+  error['Prelude.maximum: empty list']
+end
+define(:maximum) do |xs|
+  foldl1[max, xs]
+end
+
+# ###F### minimum :: Ord a => [a] -> a
+define(:minimum, [[]]) do
+  error['Prelude.maximum: empty list']
+end
+define(:minimum) do |xs|
+  foldl1[min, xs]
+end
+
+# ###F### scanl :: (a -> b -> a) -> a -> [b] -> [a]
+define(:scanl) do |f, z, xs|
+  [z] + scanl2[f, z, xs]
+end
+
+define(:scanl2, [X, X, []]) do |f, z|
+  []
+end
+define(:scanl2, [X, X, X_XS]) do |f, z, x, xs|
+  scanl[f, f[z, x], xs]
+end
+
+# ###F### scanl1 :: (a -> a -> a) -> [a] -> [a]
+define(:scanl1, [X, []]) do |f|
+  []
+end
+define(:scanl1, [X, X_XS]) do |f, x, xs|
+  scanl[f, x, xs]
+end
+
+# ###F### scanr :: (a -> b -> b) -> b -> [a] -> [b]
+define(:scanr, [X, X, []]) do |f, z|
+  [z]
+end
+define(:scanr, [X, X, X_XS]) do |f, z, x, xs|
+  qs = scanr[f, z, xs]
+  q, *qs2 = *qs
+  [f[x, q]] + qs
+end
+
+# ###F### scanr1 :: (a -> a -> a) -> [a] -> [a]
+define(:scanr1, [X, []]) do |f|
+  []
+end
+define(:scanr1, [X, [X]]) do |f, x|
+  [x]
+end
+define(:scanr1, [X, X_XS]) do |f, x, xs|
+  qs = scanr1[f, xs]
+  q, *qs2 = *qs
+  [f[x, q]] + qs
+end
+
+# ###I### iterate :: (a -> a) -> a -> [a]
+# ###I### repeat :: a -> [a]
+#   not exist suitable method in ruby...
+
+# ###N### replicate :: Int -> a -> [a]
+define(:replicate) do |n, x|
+  Array.new(n, x)
+end
+
+# ###I### cycle :: [a] -> [a]
+#   not exist suitable method in ruby...
+
+# ###F### take :: Int -> [a] -> [a]
+define(:take, [X, []]) do |n|
+  []
+end
+define(:take, [X, X_XS]) do |n, x, xs|
+  if le[n, 0]
+    []
+  else
+    [x] + take[n - 1, xs]
+  end
+end
+
+# ###F### drop :: Int -> [a] -> [a]
+define(:drop, [X, []]) do |n|
+  []
+end
+define(:drop, [X, X_XS]) do |n, x, xs|
+  if le[n, 0]
+    [x] + xs
+  else
+    drop[n - 1, xs]
+  end
+end
+
+# ###F### splitAt :: Int -> [a] -> ([a], [a])
+define(:split_at) do |n, xs|
+  [take[n, xs], drop[n, xs]]
+end
+
+# ###F### takeWhile :: (a -> Bool) -> [a] -> [a]
+define(:take_while, [X, []]) do |pr|
+  []
+end
+define(:take_while, [X, X_XS]) do |pr, x, xs|
+  if pr[x]
+    [x] + take_while[pr, xs]
+  else
+    []
+  end
+end
+
+# ###F### dropWhile :: (a -> Bool) -> [a] -> [a]
+define(:drop_while, [X, []]) do |pr|
+  []
+end
+define(:drop_while, [X, X_XS]) do |pr, x, xs|
+  if pr[x]
+    drop_while[pr, xs]
+  else
+    [x] + xs
+  end
+end
+
+# ###F### span :: (a -> Bool) -> [a] -> ([a], [a])
+define(:span, [X, []]) do |pr|
+  [[], []]
+end
+define(:span, [X, X_XS]) do |pr, x, xs|
+  if pr[x]
+    ys, zs = span[pr, xs]
+    [[x] + ys, zs]
+  else
+    [[], [x] + xs]
+  end
+end
+
+# ###F### break :: (a -> Bool) -> [a] -> ([a], [a])
+define(:break_, [X, []]) do |pr|
+  [[], []]
+end
+define(:break_, [X, X_XS]) do |pr, x, xs|
+  if pr[x]
+    [[], [x] + xs]
+  else
+    ys, zs = break_[pr, xs]
+    [[x] + ys, zs]
+  end
+end
+
+# ###F### elem :: Eq a => a -> [a] -> Bool
+define(:elem) do |x, xs|
+  any[curry(eq, x), xs]
+end
+
+# ###F### notElem :: Eq a => a -> [a] -> Bool
+define(:not_elem) do |x, xs|
+  all[curry(ne, x), xs]
+end
+
+# ###I### lookup :: Eq a => a -> [(a, b)] -> Maybe b
+#   not exist suitable method in ruby...
+
+# ###F### zip :: [a] -> [b] -> [(a, b)]
+define(:zip, [[], X]) do |ys|
+  []
+end
+define(:zip, [X, []]) do |xs|
+  []
+end
+define(:zip, [X_XS, X_XS]) do |x, xs, y, ys|
+  [[x, y]] + zip[xs, ys]
+end
+
+# ###F### zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
+define(:zip3, [[], X, X]) do |ys, zs|
+  []
+end
+define(:zip3, [X, [], X]) do |xs, zs|
+  []
+end
+define(:zip3, [X, X, []]) do |xs, ys|
+  []
+end
+define(:zip3, [X_XS, X_XS, X_XS]) do |x, xs, y, ys, z, zs|
+  [[x, y, z]] + zip3[xs, ys, zs]
+end
+
+# ###F### zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+define(:zip_with, [X, [], X]) do |f, ys|
+  []
+end
+define(:zip_with, [X, X, []]) do |f, xs|
+  []
+end
+define(:zip_with, [X, X_XS, X_XS]) do |f, x, xs, y, ys|
+  [f[x, y]] + zip_with[f, xs, ys]
+end
+
+# ###F### zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+define(:zip_with3, [X, [], X, X]) do |f, ys, zs|
+  []
+end
+define(:zip_with3, [X, X, [], X]) do |f, xs, zs|
+  []
+end
+define(:zip_with3, [X, X, X, []]) do |f, xs, ys|
+  []
+end
+define(:zip_with3, [X, X_XS, X_XS, X_XS]) do |f, x, xs, y, ys, z, zs|
+  [f[x, y, z]] + zip_with3[f, xs, ys, zs]
+end
+
+# ###F### unzip :: [(a, b)] -> ([a], [b])
+define(:unzip) do |xs|
+  foldr[lambda {|a, b| [[fst[a]] + fst[b], [snd[a]] + snd[b]]}, [[], []], xs]
+end
+
+# ###F### unzip3 :: [(a, b, c)] -> ([a], [b], [c])
+define(:unzip3) do |xs|
+  foldr[unzip32, [[], [], []], xs]
+end
+
+define(:unzip32, [[X, X, X], [X, X, X]]) do |x, y, z, xs, ys, zs|
+  [[x] + xs, [y] + ys, [z] + zs]
+end
+
+# ###F### lines :: String -> [String]
+define(:lines) do |s|
+  s.split(/\n/)
+end
+
+# ###F### words :: String -> [String]
+define(:words) do |s|
+  s.split(/\s+/)
+end
+
+# ###F### unlines :: [String] -> String
+define(:unlines) do |xs|
+  map[lambda {|s| s + "\n"}, xs].join
+end
+
+# ###F### unwords :: [String] -> String
+define(:unwords) do |xs|
+  xs.join(' ')
+end
+
+# type ShowS = String -
+# class Show a where
+# ###I### showsPrec :: Int -> a -> ShowS
+#   not exist suitable method in ruby...
+
+# ###F### show :: a -> String
+define(:show) do |x|
+  x.inspect
+end
+
+# ###I### showList :: [a] -> ShowS
+# ###I### shows :: Show a => a -> ShowS
+# ###I### showChar :: Char -> ShowS
+# ###I### showString :: String -> ShowS 
+# ###I### showParen :: Bool -> ShowS -> ShowS
+#   not exist suitable method in ruby...
+
+# type ReadS a = String -> [(a, String)]
+# class Read a where
+# ###I### readsPrec :: Int -> ReadS a
+# ###I### readList :: ReadS [a]
+# ###I### reads :: Read a => ReadS a
+# ###I### readParen :: Bool -> ReadS a -> ReadS a
+# ###I### read :: Read a => String -> a
+# ###I### lex :: ReadS String
+#   not exist suitable method in ruby...
+
+# data IO a
+# ###F### putChar :: Char -> IO ()
+define(:put_char) do |x|
+  putc x
+end
+
+# ###F### putStr :: String -> IO ()
+define(:put_str) do |x|
+  print x
+end
+
+# ###F### putStrLn :: String -> IO ()
+define(:put_str_ln) do |x|
+  puts x
+end
+
+# ###F### print :: Show a => a -> IO ()
+define(:print_) do |x|
+  p x
+end
+
+# ###F### getChar :: IO Char
+define(:get_char) do
+  $stdin.getc
+end
+
+# ###F### getLine :: IO String
+define(:get_line) do
+  $stdin.gets.chomp
+end
+
+# ###F### getContents :: IO String
+define(:get_contents) do
+  $stdin.read
+end
+
+# ###F### interact :: (String -> String) -> IO ()
+define(:interact) do |f|
+  put_str ** f ** get_contents[]
+end
+
+# type FilePath = String
+# ###F### readFile :: FilePath -> IO String
+define(:read_file) do |file|
+  Pathname(file).read
+end
+
+# ###F### writeFile :: FilePath -> String -> IO ()
+define(:write_file) do |file, s|
+  Pathname(file).open('w') do |out|
+    out.print s
+  end
+end
+
+# ###F### appendFile :: FilePath -> String -> IO ()
+define(:append_file) do |file, s|
+  Pathname(file).open('a') do |out|
+    out.print s
+  end
+end
+
+# ###I### readIO :: Read a => String -> IO a
+# ###I### readLn :: Read a => IO a
+#   not exist suitable method in ruby...
+
+# type IOError = IOException
+# ###I### ioError :: IOError -> IO a
+#   not exist suitable method in ruby...
+
+# ###F### userError :: String -> IOError
+define(:user_error) do |a|
+  raise("### Exception: user error (#{a})")
+end
+
+# ###I### catch :: IO a -> (IOError -> IO a) -> IO a
+#   not exist suitable method in ruby...