halu 0.0.1

data/History.txt

@@ -0,0 +1,5 @@
+== 0.0.1 2007-08-11
+
+  * �ŏ��̃����[�X�B
+
+  * Prelude��List�֘A�̊֐��������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/fib.rb
+example/insert_sort.rb
+example/select_sort.rb
+lib/halu.rb
+lib/halu/version.rb
+setup.rb
+test/test_halu.rb
+test/test_helper.rb

data/README.txt

@@ -0,0 +1,28 @@
+Halu ... HAskell-like List Utility
+==================================
+
+������ĉ��H
+-----------
+  Haskell���ۂ�List���C�u�����ł��B
+  Haskell��Prelude�̃��X�g�֘A�֐���S�Ď������Ă��܂��B
+
+�C���X�g�[��
+------------
+  Gem�ŃC���X�g�[�����Ă��������B
+
+    $ gem install cohi
+
+�}�j���A��
+----------
+  ���݂܂���B�����Ă��܂���B
+  lib/halu.rb���Q�Ƃ��Ă��������B
+  Haskell��Prelude�̃}�j���A�����Q�l�ɂȂ�Ǝv���܂��B
+
+�T���v��
+--------
+  example�f�B���N�g�����Q�Ƃ��Ă��������B
+
+�T�|�[�g
+--------
+  ��������܂����牺�L�܂ł��肢���܂��B
+    <tanaka.shinya@gmail.com>

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', 'halu', 'version')
+
+AUTHOR = 'TANAKA Shin-ya(id:ha-tan)'  # can also be an array of Authors
+EMAIL = "tanaka.shinya@gmail.com"
+DESCRIPTION = "Halu ... HAskell-like List Utility"
+GEM_NAME = 'halu' # 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 = 'halu' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+NAME = "halu"
+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 = Halu::VERSION::STRING + (REV ? ".#{REV}" : "")
+CLEAN.include ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']
+RDOC_OPTS = ['--quiet', '--title', 'halu 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/fib.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "ruby fib.rb" -*-
+
+$LOAD_PATH << '../lib'
+require 'halu'
+
+include Halu
+
+# �t�B�{�i�b�`����̃��X�g(�~��)��Ԃ��B
+def fib(n)
+  case n
+  when 0
+    List[0]
+  when 1
+    fib(0) >> 1
+  when 2
+    fib(1) >> 1
+  else
+    xs = fib(n - 1)
+    xs >> (xs.head + xs.tail.head)
+  end
+end
+
+p fib(0)       # => Halu::List[0]
+p fib(3)       # => Halu::List[2, 1, 1, 0]
+p fib(5)       # => Halu::List[5, 3, 2, 1, 1, 0]
+p fib(20).head # => 6765

data/example/insert_sort.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "ruby insert_sort.rb" -*-
+
+$LOAD_PATH << '../lib'
+require 'halu'
+
+include Halu
+
+def insert_sort(xs)
+  xs.fold(EMPTY_LIST) do |rs, x|
+    rs1, rs2 = rs.span {|h| h < x} # rs��x��}������ӏ���2�‚ɕ�����B
+    rs1.append(rs2 >> x)           # rs2�̓���x���‚��đS�̂�rs1�̌�ɂ‚���B
+  end
+end
+
+p insert_sort(List[8, 4, 3, 7, 6, 5, 2, 1])
+# => Halu::List[1, 2, 3, 4, 5, 6, 7, 8]

data/example/select_sort.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# -*- compile-command: "ruby select_sort.rb" -*-
+
+$LOAD_PATH << '../lib'
+require 'halu'
+
+include Halu
+
+def select_sort(xs)
+  if xs.null?
+    EMPTY_LIST
+  else
+    min = xs.minimum                # �ŏ��̗v�f�B
+    xs2 = xs.filter {|x| x != min } # ����ȊO�̗v�f�B
+    select_sort(xs2) >> min         # �ċA�I�Ƀ\�[�g�B
+                                    # �擪�ɍŏ��̗v�f�������‚���B
+  end
+end
+
+p select_sort(List[8, 4, 3, 7, 6, 5, 2, 1])
+# => Halu::List[1, 2, 3, 4, 5, 6, 7, 8]

data/lib/halu.rb

@@ -0,0 +1,502 @@
+module Halu
+  class List
+    include Enumerable
+    
+    def List::[](*ary)
+      root = list = EMPTY_LIST
+      ary.each do |h|
+        list = list << h
+        root = list if root.null?
+      end
+      root
+    end
+    
+    def initialize(h, t = EMPTY_LIST)
+      @head = h
+      @tail = t
+    end
+    
+    def each
+      list = self
+      loop do
+        yield(list.head)
+        break if list.tail.null?
+        list = list.tail
+      end
+      self
+    end
+    
+    def to_a
+      inject([]) {|ary, h| ary << h }
+    end
+    
+    def inspect
+      self.class.to_s + to_a.inspect
+    end
+    
+    def last_list
+      list = self
+      list = list.tail until list.tail.null?
+      list
+    end
+    private :last_list
+    
+    def <<(h)
+      last_list.tail = List.new(h)
+    end
+    
+    def >>(h)
+      list = List.new(h)
+      list.tail = self
+      list
+    end
+    
+    # map :: (a -> b) -> [a] -> [b]
+    def map2
+      root = list = EMPTY_LIST
+      each do |h|
+        list = list << yield(h)
+        root = list if root.null?
+      end
+      root
+    end
+    
+    # (++) :: [a] -> [a] -> [a]
+    def append(list)
+      last_list.tail = list
+      self
+    end
+    
+    # filter :: (a -> Bool) -> [a] -> [a]
+    def filter
+      root = list = EMPTY_LIST
+      each do |h|
+        if yield(h)
+          list = list << h
+          root = list if root.null?
+        end
+      end
+      root
+    end
+    
+    # head :: [a] -> a
+    attr_accessor :head
+    
+    # last :: [a] -> a
+    def last
+      inject(nil) {|r, h| h }
+    end
+    
+    # tail :: [a] -> [a]
+    attr_accessor :tail
+    
+    # init :: [a] -> [a]
+    def init
+      root = list = prelist = EMPTY_LIST
+      each do |h|
+        prelist = list
+        list = list << h
+        root = list if root.null?
+      end
+      prelist.tail = EMPTY_LIST
+      root
+    end
+    
+    # null :: [a] -> Bool
+    def null?
+      self == EMPTY_LIST
+    end
+    
+    # length :: [a] -> Int
+    def length
+      inject(0) {|r, h| r.succ }
+    end
+    
+    # (!!) :: [a] -> Int -> a
+    def at(i)
+      each_with_index do |h, j|
+        return h if i == j
+      end
+      nil
+    end
+    
+    # reverse :: [a] -> [a]
+    def reverse
+      inject(EMPTY_LIST) {|list, h| list >> h }
+    end
+    
+    # foldl :: (a -> b -> a) -> a -> [b] -> a
+    # foldl1 :: (a -> a -> a) -> [a] -> a
+    # foldr :: (a -> b -> b) -> b -> [a] -> b
+    # foldr1 :: (a -> a -> a) -> [a] -> a
+    def fold(x)
+      inject(x) {|*arg| yield(*arg) }
+    end
+    
+    def fold1
+      inject {|*arg| yield(*arg) }
+    end
+    
+    # and :: [Bool] -> Bool
+    def and?
+      each do |h|
+        return false unless h
+      end
+      true
+    end
+    
+    # or :: [Bool] -> Bool
+    def or?
+      each do |h|
+        return true if h
+      end
+      false
+    end
+    
+    # any :: (a -> Bool) -> [a] -> Bool
+    # Enumerable#any?
+    
+    # all :: (a -> Bool) -> [a] -> Bool
+    # Enumerable#all?
+    
+    # sum :: Num a => [a] -> a
+    def sum
+      inject(0) {|r, h| r + h }
+    end
+    
+    # product :: Num a => [a] -> a
+    def product
+      inject(1) {|r, h| r * h }
+    end
+    
+    # concat :: [[a]] -> [a]
+    def concat
+      root = list = EMPTY_LIST
+      each do |h|
+        list.append h
+        list = h
+        root = list if root.null?
+      end
+      root
+    end
+    
+    # concatMap :: (a -> [b]) -> [a] -> [b]
+    def concat_map(&block)
+      map2(&block).concat
+    end
+    
+    # maximum :: Ord a => [a] -> a
+    alias :maximum :max
+    
+    # minimum :: Ord a => [a] -> a
+    alias :minimum :min
+    
+    # scanl :: (a -> b -> a) -> a -> [b] -> [a]
+    # scanl1 :: (a -> a -> a) -> [a] -> [a]
+    # scanr :: (a -> b -> b) -> b -> [a] -> [b]
+    # scanr1 :: (a -> a -> a) -> [a] -> [a]
+    def scan(x)
+      root = rs = EMPTY_LIST
+      inject(x) do |r, h| 
+        root = rs = rs << r if root.null?
+        r2 = yield(r, h) 
+        rs = rs << r2
+        r2
+      end
+      root
+    end
+    
+    def scan1
+      root = rs = EMPTY_LIST
+      inject do |r, h| 
+        root = rs = rs << r if root.null?
+        r2 = yield(r, h) 
+        rs = rs << r2
+        r2
+      end
+      root
+    end
+    
+    # replicate :: Int -> a -> [a]
+    def List::replicate(n, h)
+      root = list = EMPTY_LIST
+      n.times do
+        list = list << h
+        root = list if root.null?
+      end
+      root
+    end
+    
+    # take :: Int -> [a] -> [a]
+    def take(n)
+      root = list = EMPTY_LIST
+      each_with_index do |h, i|
+        break if i >= n
+        list = list << h
+        root = list if root.null?
+      end
+      root
+    end
+    
+    # drop :: Int -> [a] -> [a]
+    def drop(n)
+      root = list = EMPTY_LIST
+      each_with_index do |h, i|
+        if i >= n
+          list = list << h
+          root = list if root.null?
+        end
+      end
+      root
+    end
+    
+    # splitAt :: Int -> [a] -> ([a], [a])
+    def split_at(n)
+      root1 = root2 = list1 = list2 = EMPTY_LIST
+      each_with_index do |h, i|
+        if i < n
+          list1 = list1 << h
+          root1 = list1 if root1.null?
+        else
+          list2 = list2 << h
+          root2 = list2 if root2.null?
+        end
+      end
+      [root1, root2]
+    end
+    
+    # takeWhile :: (a -> Bool) -> [a] -> [a]
+    def take_while
+      root = list = EMPTY_LIST
+      each do |h|
+        break unless yield(h)
+        list = list << h
+        root = list if root.null?
+      end
+      root
+    end
+
+    # dropWhile :: (a -> Bool) -> [a] -> [a]
+    def drop_while
+      root = list = EMPTY_LIST
+      drop_f = true
+      each do |h|
+        if drop_f
+          drop_f = false unless yield(h)
+        end
+        unless drop_f
+          list = list << h
+          root = list if root.null?
+        end
+      end
+      root
+    end
+
+    # span :: (a -> Bool) -> [a] -> ([a], [a])
+    def span
+      root1 = root2 = list1 = list2 = EMPTY_LIST
+      span_f = false
+      each do |h|
+        unless span_f
+          span_f = true unless yield(h)
+        end
+        unless span_f
+          list1 = list1 << h
+          root1 = list1 if root1.null?
+        else
+          list2 = list2 << h
+          root2 = list2 if root2.null?
+        end
+      end
+      [root1, root2]
+    end
+
+    # break :: (a -> Bool) -> [a] -> ([a], [a])
+    def break
+      root1 = root2 = list1 = list2 = EMPTY_LIST
+      span_f = false
+      each do |h|
+        unless span_f
+          span_f = true if yield(h)
+        end
+        unless span_f
+          list1 = list1 << h
+          root1 = list1 if root1.null?
+        else
+          list2 = list2 << h
+          root2 = list2 if root2.null?
+        end
+      end
+      [root1, root2]
+    end
+
+    # elem :: Eq a => a -> [a] -> Bool
+    def elem(h)
+      list = EMPTY_LIST
+      each do |h2|
+        return true if h == h2
+      end
+      false
+    end
+
+    # notElem :: Eq a => a -> [a] -> Bool
+    def not_elem(h)
+      not elem(h)
+    end
+
+    # lookup :: Eq a => a -> [(a, b)] -> Maybe b
+    def lookup(h)
+      list = EMPTY_LIST
+      each do |a|
+        return a[1] if h == a[0]
+      end
+      nil
+    end
+
+    # zip :: [a] -> [b] -> [(a, b)]
+    def zip2(list2)
+      return EMPTY_LIST if null?
+      return EMPTY_LIST if list2.null?
+      root = list = EMPTY_LIST
+      list1 = self
+      loop do
+        list = list << [list1.head, list2.head]
+        root = list if root.null?
+        break if list1.tail.null?
+        break if list2.tail.null?
+        list1 = list1.tail
+        list2 = list2.tail
+      end
+      root
+    end
+
+    # zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
+    def zip3(list2, list3)
+      return EMPTY_LIST if null?
+      return EMPTY_LIST if list2.null?
+      return EMPTY_LIST if list3.null?
+      root = list = EMPTY_LIST
+      list1 = self
+      loop do
+        list = list << [list1.head, list2.head, list3.head]
+        root = list if root.null?
+        break if list1.tail.null?
+        break if list2.tail.null?
+        break if list3.tail.null?
+        list1 = list1.tail
+        list2 = list2.tail
+        list3 = list3.tail
+      end
+      root
+    end
+
+    # zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+    def zip_with(list2)
+      return EMPTY_LIST if null?
+      return EMPTY_LIST if list2.null?
+      root = list = EMPTY_LIST
+      list1 = self
+      loop do
+        list = list << yield(list1.head, list2.head)
+        root = list if root.null?
+        break if list1.tail.null?
+        break if list2.tail.null?
+        list1 = list1.tail
+        list2 = list2.tail
+      end
+      root
+    end
+
+    # zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+    def zip_with3(list2, list3)
+      return EMPTY_LIST if null?
+      return EMPTY_LIST if list2.null?
+      return EMPTY_LIST if list3.null?
+      root = list = EMPTY_LIST
+      list1 = self
+      loop do
+        list = list << yield(list1.head, list2.head, list3.head)
+        root = list if root.null?
+        break if list1.tail.null?
+        break if list2.tail.null?
+        break if list3.tail.null?
+        list1 = list1.tail
+        list2 = list2.tail
+        list3 = list3.tail
+      end
+      root
+    end
+
+    # unzip :: [(a, b)] -> ([a], [b])
+    def unzip
+      root1 = root2 = list1 = list2 = EMPTY_LIST
+      each do |h|
+        list1 = list1 << h[0]
+        list2 = list2 << h[1]
+        root1 = list1 if root1.null?
+        root2 = list2 if root2.null?
+      end
+      [root1, root2]
+    end
+
+    # unzip3 :: [(a, b, c)] -> ([a], [b], [c])
+    def unzip3
+      root1 = root2 = root3 = list1 = list2 = list3 = EMPTY_LIST
+      each do |h|
+        list1 = list1 << h[0]
+        list2 = list2 << h[1]
+        list3 = list3 << h[2]
+        root1 = list1 if root1.null?
+        root2 = list2 if root2.null?
+        root3 = list3 if root3.null?
+      end
+      [root1, root2, root3]
+    end
+
+    # unlines :: [String] -> String
+    def unlines(nl = "\n")
+      inject('') do |s, h|
+        s + h.to_s + nl
+      end
+    end
+
+    # unwords :: [String] -> String
+    def unwords(sp = ' ')
+      inject('') do |s, h|
+        s + (s.empty? ? '' : sp) + h.to_s
+      end
+    end
+  end
+
+  class EmptyList < List
+    def initialize
+    end
+
+    def each
+    end
+    
+    def to_a
+      []
+    end
+
+    def <<(h)
+      List.new(h)
+    end
+
+    def >>(h)
+      List.new(h)
+    end
+
+    def append(list)
+      list
+    end
+
+    def scan(x)
+      List.new(x)
+    end
+  end
+
+  EMPTY_LIST = EmptyList.new
+end
+
+require 'halu/version'