halu 0.0.1

data/test/test_halu.rb

@@ -0,0 +1,442 @@
+# -*- compile-command: "rake test" -*-
+
+require File.dirname(__FILE__) + '/test_helper.rb'
+
+class TestHalu < Test::Unit::TestCase
+  include Halu
+
+  def setup
+  end
+
+  def test_inspect
+    assert_equal('Halu::List[1, 2, 3]', List[1, 2, 3].inspect)
+    assert_equal('Halu::EmptyList[]', List[].inspect)
+  end
+
+  def test_add
+    list = List.new(1)
+    assert_equal(2, (list << 2).head)
+    assert_equal(1, list.head)
+    assert_equal(2, list.tail.head)
+    assert_equal(EMPTY_LIST, list.tail.tail)
+
+    list = EMPTY_LIST << 3
+    assert_equal(3, list.head)
+    assert_equal(EMPTY_LIST, list.tail)
+  end
+
+  def test_unshift
+    list = List.new(1)
+    list = list >> 2
+    assert_equal(2, list.head)
+    assert_equal(1, list.tail.head)
+    assert_equal(EMPTY_LIST, list.tail.tail)
+
+    list = EMPTY_LIST >> 3
+    assert_equal(3, list.head)
+    assert_equal(EMPTY_LIST, list.tail)
+  end
+
+  def test_map2
+    assert_equal(
+      'Halu::List[2, 4, 6]', 
+      List[1, 2, 3].map2 {|h| h * 2 }.inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].map2 {|h| h * 2 }.inspect)
+  end
+
+  def test_last
+    assert_equal(3, List[1, 2, 3].last)
+    assert_equal(nil, List[].last)
+  end
+
+  def test_append
+    assert_equal(
+      'Halu::List[1, 2, 3, 4, 5, 6]',
+      List[1, 2, 3].append(List[4, 5, 6]).inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].append(List[]).inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[].append(List[1, 2, 3]).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].append(List[]).inspect)
+  end
+
+  def test_filter
+    assert_equal(
+      'Halu::List[1, 3]',
+      List[1, 2, 3].filter {|h| h % 2 == 1 }.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].filter {|h| h % 2 == 1 }.inspect)
+  end
+
+  def test_init
+    assert_equal(
+      'Halu::List[1, 2]',
+      List[1, 2, 3].init.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].init.inspect)
+  end
+
+  def test_length
+    assert_equal(3, List[1, 2, 3].length)
+    assert_equal(0, List[].length)
+  end
+
+  def test_at
+    assert_equal(2, List[1, 2, 3].at(1))
+    assert_equal(nil, List[1, 2, 3].at(4))
+    assert_equal(nil, List[1, 2, 3].at(-1))
+
+    assert_equal(nil, List[].at(0))
+  end
+
+  def test_reverse
+    assert_equal(
+      'Halu::List[3, 2, 1]',
+      List[1, 2, 3].reverse.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].reverse.inspect)
+  end
+
+  def test_fold
+    assert_equal(16, List[1, 2, 3].fold(10) {|r, h| r + h })
+    assert_equal(10, List[].fold(10) {|r, h| r + h })
+  end
+
+  def test_fold1
+    assert_equal(6, List[1, 2, 3].fold1 {|r, h| r + h })
+    assert_equal(nil, List[].fold1 {|r, h| r + h })
+  end
+
+  def test_and?
+    assert_equal(false, List[true, false, true].and?)
+    assert_equal(true, List[true, true, true].and?)
+
+    assert_equal(true, List[].and?)
+  end
+
+  def test_or?
+    assert_equal(true, List[false, true, false].or?)
+    assert_equal(false, List[false, false, false].or?)
+
+    assert_equal(false, List[].or?)
+  end
+
+  def test_any?
+    assert_equal(true, List[1, 2, 3].any? {|h| h < 3})
+    assert_equal(false, List[1, 2, 3].any? {|h| h > 3})
+
+    assert_equal(false, List[].any? {|h| h < 3})
+  end
+
+  def test_all?
+    assert_equal(true, List[1, 2, 3].all? {|h| h < 4})
+    assert_equal(false, List[1, 2, 3].all? {|h| h > 4})
+
+    assert_equal(true, List[].all? {|h| h < 4})
+  end
+
+  def test_sum
+    assert_equal(6, List[1, 2, 3].sum)
+    assert_equal(0, List[].sum)
+  end
+
+  def test_product
+    assert_equal(24, List[1, 2, 3, 4].product)
+    assert_equal(1, List[].product)
+  end
+
+  def test_concat
+    assert_equal(
+      'Halu::List[1, 2, 3, 4, 5, 6]',
+      List[List[1, 2], List[3, 4], List[5, 6]].concat.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].concat.inspect)
+  end
+
+  def test_concat_map
+    assert_equal(
+      'Halu::List[2, 4, 6]',
+      List[1, 2, 3].concat_map {|h| List[h * 2]}.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].concat_map.inspect)
+  end
+
+  def test_maximum
+    assert_equal(3, List[1, 2, 3].maximum)
+    assert_equal(nil, List[].maximum)
+  end
+
+  def test_minimum
+    assert_equal(1, List[1, 2, 3].minimum)
+    assert_equal(nil, List[].minimum)
+  end
+
+  def test_scan
+    assert_equal(
+      'Halu::List[10, 11, 13, 16]',
+      List[1, 2, 3].scan(10) {|r, h| r + h }.inspect)
+    assert_equal(
+      'Halu::List[10]', 
+      List[].scan(10) {|r, h| r + h }.inspect)
+  end
+
+  def test_scan1
+    assert_equal(
+      'Halu::List[1, 3, 6]',
+      List[1, 2, 3].scan1 {|r, h| r + h }.inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List[].scan1 {|r, h| r + h }.inspect)
+  end
+
+  def test_replicate
+    assert_equal(
+      'Halu::List[1, 1, 1]',
+      List::replicate(3, 1).inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List::replicate(0, 1).inspect)
+    assert_equal(
+      'Halu::EmptyList[]', 
+      List::replicate(-1, 1).inspect)
+  end
+
+  def test_take
+    assert_equal(
+      'Halu::List[1, 2]',
+      List[1, 2, 3].take(2).inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].take(4).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[1, 2, 3].take(0).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[1, 2, 3].take(-1).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].take(1).inspect)
+  end
+
+  def test_drop
+    assert_equal(
+      'Halu::List[3]',
+      List[1, 2, 3].drop(2).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[1, 2, 3].drop(4).inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].drop(0).inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].drop(-1).inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].drop(1).inspect)
+  end
+
+  def test_split_at
+    assert_equal(
+      '[Halu::List[1, 2], Halu::List[3]]',
+      List[1, 2, 3].split_at(2).inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::List[1, 2, 3]]',
+      List[1, 2, 3].split_at(0).inspect)
+    assert_equal(
+      '[Halu::List[1, 2, 3], Halu::EmptyList[]]',
+      List[1, 2, 3].split_at(3).inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::List[1, 2, 3]]',
+      List[1, 2, 3].split_at(-1).inspect)
+    assert_equal(
+      '[Halu::List[1, 2, 3], Halu::EmptyList[]]',
+      List[1, 2, 3].split_at(4).inspect)
+  end
+
+  def test_take_while
+    assert_equal(
+      'Halu::List[1, 2]',
+      List[1, 2, 3].take_while {|h| h < 3}.inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].take_while {|h| h < 4}.inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[1, 2, 3].take_while {|h| h < 1}.inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].take_while {|h| h < 1}.inspect)
+  end
+
+  def test_drop_while
+    assert_equal(
+      'Halu::List[3]',
+      List[1, 2, 3].drop_while {|h| h < 3}.inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[1, 2, 3].drop_while {|h| h < 4}.inspect)
+    assert_equal(
+      'Halu::List[1, 2, 3]',
+      List[1, 2, 3].drop_while {|h| h < 1}.inspect)
+    assert_equal(
+      'Halu::EmptyList[]',
+      List[].drop_while {|h| h < 1}.inspect)
+  end
+
+  def test_span
+    assert_equal(
+      '[Halu::List[1, 2], Halu::List[3]]',
+      List[1, 2, 3].span {|h| h < 3}.inspect)
+    assert_equal(
+      '[Halu::List[1, 2, 3], Halu::EmptyList[]]',
+      List[1, 2, 3].span {|h| h < 4}.inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::List[1, 2, 3]]',
+      List[1, 2, 3].span {|h| h < 1}.inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::EmptyList[]]',
+      List[].span {|h| h < 1}.inspect)
+  end
+
+  def test_break
+    assert_equal(
+      '[Halu::List[1, 2], Halu::List[3]]',
+      List[1, 2, 3].break {|h| h >= 3}.inspect)
+    assert_equal(
+      '[Halu::List[1, 2, 3], Halu::EmptyList[]]',
+      List[1, 2, 3].break {|h| h >= 4}.inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::List[1, 2, 3]]',
+      List[1, 2, 3].break {|h| h >= 1}.inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::EmptyList[]]',
+      List[].span {|h| h >= 1}.inspect)
+  end
+
+  def test_elem
+    assert_equal(true, List[1, 2, 3].elem(2))
+    assert_equal(false, List[1, 2, 3].elem(0))
+    assert_equal(false, List[].elem(0))
+  end
+
+  def test_not_elem
+    assert_equal(false, List[1, 2, 3].not_elem(2))
+    assert_equal(true, List[1, 2, 3].not_elem(0))
+    assert_equal(true, List[].not_elem(0))
+  end
+
+  def test_lookup
+    assert_equal(:bbb, 
+      List[[1, :aaa], [2, :bbb], [3, :ccc]].lookup(2))
+    assert_equal(nil, 
+      List[[1, :aaa], [2, :bbb], [3, :ccc]].lookup(0))
+    assert_equal(nil, 
+      List[].lookup(0))
+  end
+
+  def test_zip2
+    assert_equal('Halu::List[[1, 4], [2, 5], [3, 6]]',
+      List[1, 2, 3].zip2(List[4, 5, 6]).inspect)
+    assert_equal('Halu::List[[1, 4], [2, 5]]',
+      List[1, 2, 3].zip2(List[4, 5]).inspect)
+    assert_equal('Halu::List[[1, 4], [2, 5]]',
+      List[1, 2].zip2(List[4, 5, 6]).inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[].zip2(List[4, 5, 6]).inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip2(List[]).inspect)
+  end
+
+  def test_zip3
+    assert_equal('Halu::List[[1, 4, 7], [2, 5, 8], [3, 6, 9]]',
+      List[1, 2, 3].zip3(List[4, 5, 6], List[7, 8, 9]).inspect)
+    assert_equal('Halu::List[[1, 4, 7], [2, 5, 8]]',
+      List[1, 2, 3].zip3(List[4, 5, 6], List[7, 8]).inspect)
+    assert_equal('Halu::List[[1, 4, 7], [2, 5, 8]]',
+      List[1, 2, 3].zip3(List[4, 5], List[7, 8, 9]).inspect)
+    assert_equal('Halu::List[[1, 4, 7], [2, 5, 8]]',
+      List[1, 2].zip3(List[4, 5, 6], List[7, 8, 9]).inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[].zip3(List[4, 5, 6], List[7, 8, 9]).inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip3(List[], List[7, 8, 9]).inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip3(List[4, 5, 6], List[]).inspect)
+  end
+
+  def test_zip_with
+    assert_equal('Halu::List[5, 7, 9]',
+      List[1, 2, 3].zip_with(List[4, 5, 6]) {|a, b| a + b}.inspect)
+    assert_equal('Halu::List[5, 7]',
+      List[1, 2, 3].zip_with(List[4, 5]) {|a, b| a + b}.inspect)
+    assert_equal('Halu::List[5, 7]',
+      List[1, 2].zip_with(List[4, 5, 6]) {|a, b| a + b}.inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[].zip_with(List[4, 5, 6]) {|a, b| a + b}.inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip_with(List[]) {|a, b| a + b}.inspect)
+  end
+
+  def test_zip_with3
+    assert_equal('Halu::List[12, 15, 18]',
+      List[1, 2, 3].zip_with3(
+        List[4, 5, 6], List[7, 8, 9]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::List[12, 15]',
+      List[1, 2, 3].zip_with3(
+        List[4, 5, 6], List[7, 8]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::List[12, 15]',
+      List[1, 2, 3].zip_with3(
+        List[4, 5], List[7, 8, 9]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::List[12, 15]',
+      List[1, 2].zip_with3(
+        List[4, 5, 6], List[7, 8, 9]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[].zip_with3(List[
+          4, 5, 6], List[7, 8, 9]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip_with3(
+        List[], List[7, 8, 9]) {|a, b, c| a + b + c}.inspect)
+    assert_equal('Halu::EmptyList[]',
+      List[1, 2, 3].zip_with3(
+        List[4, 5, 6], List[]) {|a, b, c| a + b + c}.inspect)
+  end
+
+  def test_unzip
+    assert_equal('[Halu::List[1, 3, 5], Halu::List[2, 4, 6]]',
+      List[[1, 2], [3, 4], [5, 6]].unzip.inspect)
+    assert_equal('[Halu::EmptyList[], Halu::EmptyList[]]',
+      List[].unzip.inspect)
+  end
+
+  def test_unzip3
+    assert_equal(
+      '[Halu::List[1, 4, 7], Halu::List[2, 5, 8], Halu::List[3, 6, 9]]',
+      List[[1, 2, 3], [4, 5, 6], [7, 8, 9]].unzip3.inspect)
+    assert_equal(
+      '[Halu::EmptyList[], Halu::EmptyList[], Halu::EmptyList[]]',
+      List[].unzip3.inspect)
+  end
+
+  def test_unlines
+    assert_equal("aaa\nbbb\nccc\n", List['aaa', 'bbb', 'ccc'].unlines)
+    assert_equal('', List[].unlines)
+  end
+
+  def test_unwords
+    assert_equal('aaa bbb ccc', List['aaa', 'bbb', 'ccc'].unwords)
+    assert_equal('', List[].unwords)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/halu'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: halu
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-08-11 00:00:00 +09:00
+summary: Halu ... HAskell-like List Utility
+require_paths: 
+- lib
+email: tanaka.shinya@gmail.com
+homepage: http://halu.rubyforge.org
+rubyforge_project: halu
+description: Halu ... HAskell-like List Utility
+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/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
+test_files: 
+- test/test_halu.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: []
+