list 0.0.1 → 0.1.0

data/list.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "list"
-  spec.version       = "0.0.1"
+  spec.version       = "0.1.0"
   spec.author        = "ksss"
   spec.email         = "co000ri@gmail.com"
   spec.summary       = %q{List in Ruby}

data/spec/bench.rb

@@ -7,7 +7,7 @@ require 'list'
 require 'benchmark'
 
 Benchmark.bm(32) do |x|
-  [1000,10000,100000].each do |n|
+  [100000].each do |n|
     x.report("#{n}times") do
       n.times do
       end
@@ -15,7 +15,7 @@ Benchmark.bm(32) do |x|
   end
 
   [Array, List].each do |obj|
-    [1000,10000,100000].each do |n|
+    [100000].each do |n|
       x.report("#{obj}#new #{n}times") do
         n.times do
           obj.new
@@ -24,16 +24,17 @@ Benchmark.bm(32) do |x|
     end
   end
 
-  [[:push, 1], [:unshift, 1], [:pop], [:shift], [:insert, 0, 1], [:delete_at, 0]].each do |args|
+  [[:[], 100000], [:push, 1], [:unshift, 1], [:pop], [:shift], [:insert, 0, 1], [:delete_at, 0]].each do |args|
     m = args.shift
     [(0..100000).to_a, (0..100000).to_list].each do |obj|
-      [1000,10000,100000].each do |n|
+      [100000].each do |n|
         o = obj.dup
         x.report("#{o.class}##{m} #{n}times") do
           n.times do
             o.send(m, *args)
           end
         end
+        GC.start
       end
     end
   end

data/spec/list_spec.rb

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe List do
+  before :all do
+    @cls = List
+    @subcls = L
+  end
+
   before :each do
     GC.start
   end
@@ -10,96 +15,104 @@ describe List do
   end
 
   it "class" do
-    expect(List).to be_include(Enumerable)
+    expect(@cls).to be_include(Enumerable)
   end
 
   it "create" do
-    expect(List[]).to eq(List.new)
-    expect(List[1,2,3]).to eq(List.new [1,2,3])
-    expect(L[1,2,3]).to eq(L.new [1,2,3])
+    expect(@cls[]).to eq(@cls.new)
+    expect(@cls[1,2,3]).to eq(@cls.new [1,2,3])
+    expect(@subcls[1,2,3]).to eq(@subcls.new [1,2,3])
   end
 
   it "try_convert" do
-    expect(List.try_convert List[1,2,3]).to eq(List[1,2,3])
-    expect(List.try_convert [1,2,3]).to eq(List[1,2,3])
-    expect(List.try_convert "[1,2,3]").to eq(nil)
+    expect(@cls.try_convert @cls[1,2,3]).to eq(@cls[1,2,3])
+    expect(@cls.try_convert [1,2,3]).to eq(@cls[1,2,3])
+    expect(@cls.try_convert "[1,2,3]").to eq(nil)
   end
 
   it "to_list" do
-    expect([].to_list).to eq(List.new)
-    expect([1,[2],3].to_list).to eq(List[1,[2],3])
-    expect((0..5).to_list).to eq(List[0,1,2,3,4,5])
-    expect(List[1,2,3].to_list).to eq(List[1,2,3])
-    expect(L[1,2,3].to_list).to eq(L[1,2,3])
+    expect([].to_list).to eq(@cls.new)
+    expect([1,[2],3].to_list).to eq(@cls[1,[2],3])
+    expect((0..5).to_list).to eq(@cls[0,1,2,3,4,5])
+    expect(@cls[1,2,3].to_list).to eq(@cls[1,2,3])
+    expect(@subcls[1,2,3].to_list).to eq(@subcls[1,2,3])
+    klass = Class.new(Array)
+    list = klass.new.to_list
+    expect(list).to eq(@cls[])
+    expect(list.class).to eq(@cls)
   end
 
   it "initialize" do
-    expect(List.new).to be_a_kind_of(List)
-    expect(List.new([])).to be_a_kind_of(List)
-    expect(List.new([1,2,3])).to be_a_kind_of(List)
-    expect(List.new([1,2,3])).to eq([1,2,3].to_list)
-    expect(List.new(3)).to eq([nil,nil,nil].to_list)
-    expect(List.new(3, 0)).to eq([0,0,0].to_list)
-    expect(List.new(3){|i| "foo"}).to eq(["foo", "foo", "foo"].to_list)
-    expect{List.new(3,0,0)}.to raise_error(ArgumentError)
-    expect{List.new("a")}.to raise_error(TypeError)
-    expect{List.new("a",0)}.to raise_error(TypeError)
+    expect(@cls.new).to be_a_kind_of(@cls)
+    expect(@subcls.new).to be_a_kind_of(@cls)
+    expect(@cls.new([])).to be_a_kind_of(@cls)
+    expect(@cls.new([1,2,3])).to be_a_kind_of(@cls)
+    expect(@cls.new([1,2,3])).to eq(@cls[1,2,3])
+    expect(@cls.new(3)).to eq(@cls[nil,nil,nil])
+    expect(@cls.new(3, 0)).to eq(@cls[0,0,0])
+    expect(@cls.new(3){|i| "foo"}).to eq(@cls["foo", "foo", "foo"])
+    expect{@cls.new.instance_eval{ initialize }}.to_not raise_error
+    expect{@cls.new {}}.to_not raise_error
+    expect{@cls.new(3,0,0)}.to raise_error(ArgumentError)
+    expect{@cls.new(-1,1)}.to raise_error(ArgumentError)
+    expect{@cls.new("a")}.to raise_error(TypeError)
+    expect{@cls.new("a",0)}.to raise_error(TypeError)
   end
 
   it "dup and replace" do
-    list = List.new
+    list = @cls.new
     expect(list.dup).to eq(list)
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     expect(list.dup).to eq(list)
   end
 
   it "inspect" do
-    list = List.new
-    expect(list.inspect).to eq("#<List: []>")
+    list = @cls.new
+    expect(list.inspect).to eq("#<#{@cls}: []>")
     list.push 1,[2],{:a=>3}
-    expect(list.inspect).to eq("#<List: [1, [2], {:a=>3}]>")
-    expect(L[1,2,3].inspect).to eq("#<L: [1, 2, 3]>")
+    expect(list.inspect).to eq("#<#{@cls}: [1, [2], {:a=>3}]>")
+    expect(@subcls[1,2,3].inspect).to eq("#<#{@subcls}: [1, 2, 3]>")
   end
 
   it "to_a" do
-    list = List.new
+    list = @cls.new
     expect(list.to_a).to eq([])
     a = (0..10).to_a
-    list = List.new(a)
+    list = @cls.new(a)
     expect(list.to_a).to eq(a)
   end
 
   it "freeze and frozen?" do
-    list = List.new
+    list = @cls.new
     list.freeze
-    expect(list).to eq(List[])
+    expect(list).to eq(@cls[])
     expect(list.frozen?).to eq(true)
     expect{ list.push 1 }.to raise_error
   end
 
   it "==" do
-    list = List.new
-    expect(list).to eq(List.new)
+    list = @cls.new
+    expect(list).to eq(@cls.new)
     expect(list).to eq(list)
     list.push(1)
-    expect(list).to_not eq(List.new)
-    expect(list).to eq(List[1])
+    expect(list).to_not eq(@cls.new)
+    expect(list).to eq(@cls[1])
     expect(list).to_not eq([1])
-    expect(L[1]).to eq(L[1])
-    expect(L[1]).to eq(List[1])
+    expect(@subcls[1]).to eq(@subcls[1])
+    expect(@subcls[1]).to eq(@cls[1])
   end
 
   it "eql?" do
-    list = List.new
+    list = @cls.new
     expect(list.eql?(list)).to be true
-    expect(list.eql?(List.new)).to be false
-    expect(list.eql?(L.new)).to be false
+    expect(list.eql?(@cls.new)).to be false
+    expect(list.eql?(@subcls.new)).to be false
   end
 
   it "hash" do
-    expect(List.new.hash).to eq(List.new.hash)
-    list1 = List[1,2,3]
-    list2 = List[1,2,3]
+    expect(@cls.new.hash).to eq(@cls.new.hash)
+    list1 = @cls[1,2,3]
+    list2 = @cls[1,2,3]
     expect(list1.hash).to eq(list2.hash)
     hash = {}
     hash[list1] = 1
@@ -107,66 +120,74 @@ describe List do
   end
 
   it "[]" do
-    list = List.new
+    list = @cls.new
     expect(list[0]).to eq(nil)
     list.push 1,2,3
     expect(list[2]).to eq(3)
     expect(list[-1]).to eq(3)
     expect(list[10]).to eq(nil)
-    expect(list[1,1]).to eq(List[2])
-    expect(list[1,2]).to eq(List[2,3])
-    expect(list[1,10]).to eq(List[2,3])
+    expect(list[1,1]).to eq(@cls[2])
+    expect(list[1,2]).to eq(@cls[2,3])
+    expect(list[1,10]).to eq(@cls[2,3])
 
     # special cases
     expect(list[3]).to eq(nil)
     expect(list[10,0]).to eq(nil)
-    expect(list[3,0]).to eq(List[])
-    expect(list[3..10]).to eq(List[])
+    expect(list[3,0]).to eq(@cls[])
+    expect(list[3..10]).to eq(@cls[])
+
+    expect{@cls[][0,0,0]}.to raise_error(ArgumentError)
   end
 
   it "[]=" do
-    list = List.new
+    list = @cls.new
     list[0] = 1
-    expect(list).to eq(List[1])
+    expect(list).to eq(@cls[1])
     list[1] = 2
-    expect(list).to eq(List[1,2])
+    expect(list).to eq(@cls[1,2])
     list[4] = 4
-    expect(list).to eq(List[1,2,nil,nil,4])
-    list[0,3] = List['a','b','c']
-    expect(list).to eq(List['a','b','c',nil,4])
-    list[0,3] = List['a','b','c']
-    expect(list).to eq(List['a','b','c',nil,4])
-    list[1..2] = List[1,2]
-    expect(list).to eq(List['a',1,2,nil,4])
+    expect(list).to eq(@cls[1,2,nil,nil,4])
+    list[0,3] = @cls['a','b','c']
+    expect(list).to eq(@cls['a','b','c',nil,4])
+    list[0,3] = @cls['a','b','c']
+    expect(list).to eq(@cls['a','b','c',nil,4])
+    list[1..2] = @cls[1,2]
+    expect(list).to eq(@cls['a',1,2,nil,4])
     list[0,2] = "?"
-    expect(list).to eq(List["?",2,nil,4])
+    expect(list).to eq(@cls["?",2,nil,4])
     list[0..2] = "A"
-    expect(list).to eq(List["A",4])
+    expect(list).to eq(@cls["A",4])
     list[-1] = "Z"
-    expect(list).to eq(List["A","Z"])
+    expect(list).to eq(@cls["A","Z"])
     list[1..-1] = nil
-    expect(list).to eq(List["A",nil])
-    list[1..-1] = List[]
-    expect(list).to eq(List["A"])
-    list[0,0] = List[1,2]
-    expect(list).to eq(List[1,2,"A"])
+    expect(list).to eq(@cls["A",nil])
+    list[1..-1] = @cls[]
+    expect(list).to eq(@cls["A"])
+    list[0,0] = @cls[1,2]
+    expect(list).to eq(@cls[1,2,"A"])
     list[3,0] = "B"
-    expect(list).to eq(List[1,2,"A","B"])
+    expect(list).to eq(@cls[1,2,"A","B"])
     list[6,0] = "C"
-    expect(list).to eq(List[1,2,"A","B",nil,nil,"C"])
-    expect{list["10"]}.to raise_error(TypeError)
+    expect(list).to eq(@cls[1,2,"A","B",nil,nil,"C"])
 
-    a = List[1,2,3]
+    a = @cls[1,2,3]
     a[1,0] = a
-    expect(a).to eq(List[1,1,2,3,2,3]);
+    expect(a).to eq(@cls[1,1,2,3,2,3]);
 
-    a = List[1,2,3]
+    a = @cls[1,2,3]
     a[-1,0] = a
-    expect(a).to eq(List[1,2,1,2,3,3]);
+    expect(a).to eq(@cls[1,2,1,2,3,3]);
+
+    expect{@cls[0][-2] = 1}.to raise_error(IndexError)
+    expect{@cls[0][-2,0] = nil}.to raise_error(IndexError)
+    expect{@cls[0][0,0,0] = 0}.to raise_error(ArgumentError)
+    expect{@cls[0].freeze[0,0,0] = 0}.to raise_error(ArgumentError)
+    expect{@cls[0][:foo] = 0}.to raise_error(TypeError)
+    expect{@cls[0].freeze[:foo] = 0}.to raise_error(RuntimeError)
   end
 
   it "at" do
-    list = List.new
+    list = @cls.new
     expect(list.at(0)).to eq(nil)
     list.push 1,2,3
     expect(list.at(0)).to eq(1)
@@ -176,91 +197,97 @@ describe List do
   end
 
   it "fetch" do
-    list = List[11,22,33,44]
+    list = @cls[11,22,33,44]
     expect(list.fetch(1)).to eq(22)
     expect(list.fetch(-1)).to eq(44)
     expect(list.fetch(4, 'cat')).to eq('cat')
     expect(list.fetch(100){|i| "#{i} is out of bounds" }).to eq('100 is out of bounds')
-    expect{list.fetch(100)}.to raise_error(IndexError)
-    expect{list.fetch("100")}.to raise_error(TypeError)
+
+    expect{@cls[0,1].fetch(100)}.to raise_error(IndexError)
+    expect{@cls[0,1].fetch(-100)}.to raise_error(IndexError)
+    expect{@cls[0,1].fetch("100")}.to raise_error(TypeError)
   end
 
   it "first" do
-    list = List.new
+    list = @cls.new
     expect(list.first).to eq(nil)
     list.push 1,2,3
     expect(list.first).to eq(1)
     expect(list.first).to eq(1)
-    expect(list.first(2)).to eq(List[1,2])
-    expect(list.first(10)).to eq(List[1,2,3])
+    expect(list.first(2)).to eq(@cls[1,2])
+    expect(list.first(10)).to eq(@cls[1,2,3])
     expect{list.first("1")}.to raise_error(TypeError)
     expect{list.first(-1)}.to raise_error(ArgumentError)
   end
 
   it "last" do
-    list = List.new
+    list = @cls.new
     expect(list.last).to eq(nil)
     list.push 1,2,3
     expect(list.last).to eq(3)
     expect(list.last).to eq(3)
-    expect(list.last(2)).to eq(List[2,3])
-    expect(list.last(10)).to eq(List[1,2,3])
+    expect(list.last(2)).to eq(@cls[2,3])
+    expect(list.last(10)).to eq(@cls[1,2,3])
     expect{list.last("1")}.to raise_error(TypeError)
     expect{list.last(-1)}.to raise_error(ArgumentError)
   end
 
   it "concat" do
-    list = List.new
-    list2 = List[1,2,3]
-    expect(list.concat(list2)).to eq(List[1,2,3])
-    expect(list.concat([4,5,6])).to eq(List[1,2,3,4,5,6])
-    expect(list.concat(L[7,8,9])).to eq(List[1,2,3,4,5,6,7,8,9])
+    list = @cls.new
+    list2 = @cls[1,2,3]
+    expect(list.concat(list2)).to eq(@cls[1,2,3])
+    expect(list.concat([4,5,6])).to eq(@cls[1,2,3,4,5,6])
+    expect(list.concat(@subcls[7,8,9])).to eq(@cls[1,2,3,4,5,6,7,8,9])
   end
 
   it "push" do
-    list = List.new
+    list = @cls.new
     expect(list.push).to eq(list)
     10.times { |i|
       list << i
     }
-    expect(list).to eq((0...10).to_list)
-    list.push(*(10...20).to_a)
-    expect(list).to eq((0...20).to_list)
+    expect(list).to eq(@cls[*0...10])
+    list.push(*(10...20))
+    expect(list).to eq(@cls[*0...20])
   end
 
   it "pop" do
-    list = List.new
+    list = @cls.new
     expect(list.pop).to eq(nil)
     list.push 1,2,3
-    expect(list.pop(2).to_a).to eq([2,3])
+    expect(list.pop(2)).to eq(@cls[2,3])
     expect(list.pop).to eq(1)
     expect{list.pop("1")}.to raise_error(TypeError) 
   end
 
   it "shift" do
-    list = List.new
+    list = @cls.new
     expect(list.shift).to eq(nil)
     list.push 1,2,3
-    expect(list.shift(2).to_a).to eq([1,2])
+    expect(list.shift(2)).to eq(@cls[1,2])
     expect(list.shift).to eq(3)
     expect{list.shift("1")}.to raise_error(TypeError) 
   end
 
   it "unshift" do
-    list = List.new
+    list = @cls.new
     expect(list.unshift).to eq(list)
-    expect(list.unshift(3).to_a).to eq([3])
-    expect(list.unshift(2,1).to_a).to eq([1,2,3])
+    expect(list.unshift(3)).to eq(@cls[3])
+    expect(list.unshift(1,2)).to eq(@cls[1,2,3])
+    expect(list.unshift(@cls["foo","bar"])).to eq(@cls[@cls["foo","bar"],1,2,3])
+
+    expect{@cls[].freeze.unshift('cat')}.to raise_error(RuntimeError)
+    expect{@cls[].freeze.unshift()}.to raise_error(RuntimeError)
   end
 
   it "insert" do
-    list = List['a','b','c','d']
-    expect(list.insert(2, 99)).to eq(List["a","b",99,"c","d"]);
+    list = @cls['a','b','c','d']
+    expect(list.insert(2, 99)).to eq(@cls["a","b",99,"c","d"]);
     expect{list.insert("a", 1)}.to raise_error(TypeError)
   end
 
   it "each" do
-    list = List.new
+    list = @cls.new
     expect(list.each).to be_a_kind_of(Enumerator)
     expect(list.each{}).to eq(list)
 
@@ -278,7 +305,7 @@ describe List do
   end
 
   it "each_index" do
-    list = List.new
+    list = @cls.new
     expect(list.each_index).to be_a_kind_of(Enumerator)
     expect(list.each_index{}).to eq(list)
 
@@ -296,7 +323,7 @@ describe List do
   end
 
   it "reverse_each" do
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     result = []
     list.reverse_each do |i|
       result << i
@@ -305,7 +332,7 @@ describe List do
   end
 
   it "length" do
-    list = List.new
+    list = @cls.new
     expect(list.length).to eq(0)
     list.push 1,2,3
     expect(list.length).to eq(3)
@@ -313,14 +340,14 @@ describe List do
   end
 
   it "empty?" do
-    list = List.new
+    list = @cls.new
     expect(list.empty?).to eq(true)
     list.push 1,2,3
     expect(list.empty?).to eq(false)
   end
 
   it "find_index" do
-    list = List.new
+    list = @cls.new
     expect(list.find_index(1)).to eq(nil)
     list.push 1,2,3
     expect(list.find_index(1)).to eq(0)
@@ -329,267 +356,300 @@ describe List do
   end
 
   it "replace" do
-    list = List[1,2,3,4,5]
-    expect(list.replace(List[4,5,6])).to eq(List[4,5,6])
-    expect(list.replace([7,8,9])).to eq(List[7,8,9])
+    list = @cls[1,2,3,4,5]
+    expect(list.replace(@cls[4,5,6])).to eq(@cls[4,5,6])
+    expect(list.replace([7,8,9])).to eq(@cls[7,8,9])
     expect{list.replace "1"}.to raise_error(TypeError)
   end
 
   it "clear" do
-    list = List[1,2,3]
-    expect(list.clear).to eq(List[])
-    expect(list.clear).to eq(List[])
+    list = @cls[1,2,3]
+    expect(list.clear).to eq(@cls[])
+    expect(list.clear).to eq(@cls[])
   end
 
   it "rindex" do
-    list = List[1,2,2,2,3]
+    list = @cls[1,2,2,2,3]
     expect(list.rindex(2)).to eq(3)
     expect(list.rindex(-10)).to eq(nil)
     expect(list.rindex { |x| x == 2 }).to eq(3)
+
+    list = @cls[0,1]
+    e = list.rindex
+    expect(e.next).to eq(1)
+    list.clear
+    expect{e.next}.to raise_error(StopIteration)
+
+    obj = Object.new
+    class << obj; self; end.class_eval do
+      define_method(:==) {|x| list.clear; false}
+    end
+    list = @cls[nil,obj]
+    expect(list.rindex(0)).to eq(nil)
   end
 
   it "join" do
-    expect(List.new.join).to eq("")
-    expect(List[1,2,3].join).to eq("123")
-    expect(List["a","b","c"].join).to eq("abc")
-    expect(List["a","b","c"].join("-")).to eq("a-b-c")
-    expect(List["a",List["b",List["c"]]].join("-")).to eq("a-b-c")
-    expect{List["a","b","c"].join(1)}.to raise_error(TypeError)
+    expect(@cls.new.join).to eq("")
+    expect(@cls[1,2,3].join).to eq("123")
+    expect(@cls["a","b","c"].join).to eq("abc")
+    expect(@cls["a","b","c"].join("-")).to eq("a-b-c")
+    expect(@cls["a",@cls["b",@cls["c"]]].join("-")).to eq("a-b-c")
+    expect(@cls["a",["b",@cls[["c"]]]].join("-")).to eq("a-b-c")
+    expect{@cls["a","b","c"].join(1)}.to raise_error(TypeError)
     orig_sep = $,
     $, = "*"
-    expect(List["a","b","c"].join).to eq("a*b*c")
+    expect(@cls["a","b","c"].join).to eq("a*b*c")
     $, = orig_sep
+
+    def (a = Object.new).to_list
+      List[self]
+    end
+    expect{@cls[a].join}.to raise_error(ArgumentError)
   end
 
   it "reverse" do
-    list = List.new
-    expect(list.reverse).to eq(List.new)
+    list = @cls.new
+    expect(list.reverse).to eq(@cls.new)
     list.push 1,2,3
-    expect(list.reverse).to eq(List[3,2,1])
-    expect(list).to eq(List[1,2,3])
+    expect(list.reverse).to eq(@cls[3,2,1])
+    expect(list).to eq(@cls[1,2,3])
   end
 
   it "reverse!" do
-    list = List.new
-    expect(list.reverse!).to eq(List.new)
+    list = @cls.new
+    expect(list.reverse!).to eq(@cls.new)
     list.push 1,2,3
-    expect(list.reverse!).to eq(List[3,2,1])
-    expect(list).to eq(List[3,2,1])
+    expect(list.reverse!).to eq(@cls[3,2,1])
+    expect(list).to eq(@cls[3,2,1])
   end
 
   it "rotate" do
-    list = List.new
-    expect(list.rotate).to eq(List.new)
+    list = @cls.new
+    expect(list.rotate).to eq(@cls.new)
     list.push 1,2,3
-    expect(list.rotate).to eq(List[2,3,1])
-    expect(list.rotate(2)).to eq(List[3,1,2])
-    expect(list.rotate(-2)).to eq(List[2,3,1])
-    expect(list).to eq(List[1,2,3])
+    expect(list.rotate).to eq(@cls[2,3,1])
+    expect(list.rotate(2)).to eq(@cls[3,1,2])
+    expect(list.rotate(-2)).to eq(@cls[2,3,1])
+    expect(list).to eq(@cls[1,2,3])
     expect{list.rotate("a")}.to raise_error(TypeError)
     expect{list.rotate(1,2)}.to raise_error(ArgumentError)
   end
 
   it "rotate!" do
-    list = List.new
-    expect(list.rotate!).to eq(List.new)
+    list = @cls.new
+    expect(list.rotate!).to eq(@cls.new)
     list.push 1,2,3
-    expect(list.rotate!).to eq(List[2,3,1])
-    expect(list.rotate!(2)).to eq(List[1,2,3])
-    expect(list.rotate!(-2)).to eq(List[2,3,1])
-    expect(list).to eq(List[2,3,1])
+    expect(list.rotate!).to eq(@cls[2,3,1])
+    expect(list.rotate!(2)).to eq(@cls[1,2,3])
+    expect(list.rotate!(-2)).to eq(@cls[2,3,1])
+    expect(list).to eq(@cls[2,3,1])
     expect{list.rotate!("a")}.to raise_error(TypeError)
     expect{list.rotate!(1,2)}.to raise_error(ArgumentError)
   end
 
   it "sort" do
-    list = List.new
-    expect(list.sort).to eq(List.new)
+    list = @cls.new
+    expect(list.sort).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.sort).to eq(List[1,2,3,4,5])
-    expect(list.sort{|a,b| b - a}).to eq(List[5,4,3,2,1])
-    expect(list).to eq(List[4,1,3,5,2])
+    expect(list.sort).to eq(@cls[1,2,3,4,5])
+    expect(list.sort{|a,b| b - a}).to eq(@cls[5,4,3,2,1])
+    expect(list).to eq(@cls[4,1,3,5,2])
   end
 
   it "sort!" do
-    list = List.new
-    expect(list.sort!).to eq(List.new)
+    list = @cls.new
+    expect(list.sort!).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.sort!).to eq(List[1,2,3,4,5])
-    expect(list).to eq(List[1,2,3,4,5])
-    expect(list.sort!{|a,b| b - a}).to eq(List[5,4,3,2,1])
-    expect(list).to eq(List[5,4,3,2,1])
+    expect(list.sort!).to eq(@cls[1,2,3,4,5])
+    expect(list).to eq(@cls[1,2,3,4,5])
+    expect(list.sort!{|a,b| b - a}).to eq(@cls[5,4,3,2,1])
+    expect(list).to eq(@cls[5,4,3,2,1])
   end
 
   it "sort_by" do
-    list = List.new
-    expect(list.sort_by{|a| a}).to eq(List.new)
+    list = @cls.new
+    expect(list.sort_by{|a| a}).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.sort_by{|a| a}).to eq(List[1,2,3,4,5])
-    expect(list.sort_by{|a| -a}).to eq(List[5,4,3,2,1])
-    expect(list).to eq(List[4,1,3,5,2])
+    expect(list.sort_by{|a| a}).to eq(@cls[1,2,3,4,5])
+    expect(list.sort_by{|a| -a}).to eq(@cls[5,4,3,2,1])
+    expect(list).to eq(@cls[4,1,3,5,2])
   end
 
   it "sort_by!" do
-    list = List.new
-    expect(list.sort_by!{|a| a}).to eq(List.new)
+    list = @cls.new
+    expect(list.sort_by!{|a| a}).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.sort_by!{|a| a}).to eq(List[1,2,3,4,5])
-    expect(list.sort_by!{|a| -a}).to eq(List[5,4,3,2,1])
-    expect(list).to eq(List[5,4,3,2,1])
+    expect(list.sort_by!{|a| a}).to eq(@cls[1,2,3,4,5])
+    expect(list.sort_by!{|a| -a}).to eq(@cls[5,4,3,2,1])
+    expect(list).to eq(@cls[5,4,3,2,1])
   end
 
   it "collect" do
-    list = List.new
-    expect(list.collect{|a| a}).to eq(List.new)
+    list = @cls.new
+    expect(list.collect{|a| a}).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.collect{|a| a * a}).to eq(List[16,1,9,25,4])
-    expect(list.map.each{|a| -a}).to eq(List[-4,-1,-3,-5,-2])
-    expect(list).to eq(List[4,1,3,5,2])
+    expect(list.collect{|a| a * a}).to eq(@cls[16,1,9,25,4])
+    expect(list.map.each{|a| -a}).to eq(@cls[-4,-1,-3,-5,-2])
+    expect(list).to eq(@cls[4,1,3,5,2])
   end
 
   it "collect!" do
-    list = List.new
-    expect(list.collect!{|a| a}).to eq(List.new)
+    list = @cls.new
+    expect(list.collect!{|a| a}).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.collect!{|a| a * a}).to eq(List[16,1,9,25,4])
-    expect(list.map!.each{|a| -a}).to eq(List[-16,-1,-9,-25,-4])
+    expect(list.collect!{|a| a * a}).to eq(@cls[16,1,9,25,4])
+    expect(list.map!.each{|a| -a}).to eq(@cls[-16,-1,-9,-25,-4])
   end
 
   it "select" do
-    list = List.new
-    expect(list.select{|i| i}).to eq(List.new)
+    list = @cls.new
+    expect(list.select{|i| i}).to eq(@cls.new)
     list.push *[4,1,3,5,2]
-    expect(list.select{|i| i.even?}).to eq(List[4,2])
-    expect(list.select.each{|i| i.odd?}).to eq(List[1,3,5])
-    expect(list).to eq(List[4,1,3,5,2])
+    expect(list.select{|i| i.even?}).to eq(@cls[4,2])
+    expect(list.select.each{|i| i.odd?}).to eq(@cls[1,3,5])
+    expect(list).to eq(@cls[4,1,3,5,2])
   end
 
   it "select!" do
-    list = List.new
+    list = @cls.new
     expect(list.select!{|i| i}).to eq(nil)
     list.push *[4,1,3,5,2]
-    expect(list.select!{|i| i.even?}).to eq(List[4,2])
-    expect(list.select!.each{|i| i % 4 == 0}).to eq(List[4])
+    expect(list.select!{|i| i.even?}).to eq(@cls[4,2])
+    expect(list.select!.each{|i| i % 4 == 0}).to eq(@cls[4])
     expect(list.select!.each{|i| i % 4 == 0}).to eq(nil)
-    expect(list).to eq(List[4])
+    expect(list).to eq(@cls[4])
   end
 
   it "keep_if" do
-    list = List.new
+    list = @cls.new
     expect(list.keep_if{|i| i}).to eq(list)
     list.push *[4,1,3,5,2]
-    expect(list.keep_if{|i| i.even?}).to eq(List[4,2])
-    expect(list.keep_if.each{|i| i % 4 == 0}).to eq(List[4])
+    expect(list.keep_if{|i| i.even?}).to eq(@cls[4,2])
+    expect(list.keep_if.each{|i| i % 4 == 0}).to eq(@cls[4])
     expect(list.keep_if.each{|i| i % 4 == 0}).to eq(list)
-    expect(list).to eq(List[4])
+    expect(list).to eq(@cls[4])
   end
 
   it "values_at" do
-    expect(List.new.values_at(1)).to eq(List[nil])
-    list = List[4,1,3,5,2]
-    expect(list.values_at).to eq(List.new)
-    expect(list.values_at 1).to eq(List[1])
-    expect(list.values_at 1,3,10).to eq(List[1,5,nil])
-    expect(list.values_at -1,-2).to eq(List[2,5])
-    expect(list.values_at 1..5).to eq(List[1,3,5,2,nil])
-    expect(list.values_at -2..-1).to eq(List[5,2])
-    expect(list.values_at -1..-2).to eq(List.new)
-    expect(list.values_at 0,1..5).to eq(List[4,1,3,5,2,nil])
-    expect(list.values_at 10..12).to eq(List[nil,nil,nil])
+    expect(@cls.new.values_at(1)).to eq(@cls[nil])
+    list = @cls[4,1,3,5,2]
+    expect(list.values_at).to eq(@cls.new)
+    expect(list.values_at 1).to eq(@cls[1])
+    expect(list.values_at 1,3,10).to eq(@cls[1,5,nil])
+    expect(list.values_at -1,-2).to eq(@cls[2,5])
+    expect(list.values_at 1..5).to eq(@cls[1,3,5,2,nil])
+    expect(list.values_at -2..-1).to eq(@cls[5,2])
+    expect(list.values_at -1..-2).to eq(@cls.new)
+    expect(list.values_at 0,1..5).to eq(@cls[4,1,3,5,2,nil])
+    expect(list.values_at 10..12).to eq(@cls[nil,nil,nil])
     expect{list.values_at "a"}.to raise_error(TypeError)
   end
 
   it "delete" do
-    expect(List.new.delete(nil)).to eq(nil)
-    list = List[4,1,3,2,5,5]
+    expect(@cls.new.delete(nil)).to eq(nil)
+    list = @cls[4,1,3,2,5,5]
     expect(list.delete(1)).to eq(1)
-    expect(list).to eq(List[4,3,2,5,5])
+    expect(list).to eq(@cls[4,3,2,5,5])
     expect(list.delete(5){"not found"}).to eq(5)
-    expect(list).to eq(List[4,3,2])
+    expect(list).to eq(@cls[4,3,2])
     expect(list.delete(4)).to eq(4)
     expect(list.delete(1){"not found"}).to eq("not found")
 
-    list = Array.new(1024,0).to_list
+    list = @cls.new(1024,0)
     expect(list.delete(0)).to eq(0)
-    expect(list).to eq(List.new)
+    expect(list).to eq(@cls.new)
   end
 
   it "delete_at" do
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     expect(list.delete_at(1)).to eq(2)
-    expect(list).to eq(List[1,3])
+    expect(list).to eq(@cls[1,3])
     expect(list.delete_at(-1)).to eq(3)
-    expect(list).to eq(List[1])
+    expect(list).to eq(@cls[1])
     expect(list.delete_at(0)).to eq(1)
-    expect(list).to eq(List[])
+    expect(list).to eq(@cls[])
     expect(list.delete_at(0)).to eq(nil)
     expect{list.delete_at("a")}.to raise_error(TypeError)
   end
 
   it "delete_if" do
-    list = List[1,2,3,4,5]
-    expect(list.delete_if{|i| 3 < i}).to eq(List[1,2,3])
-    expect(list.delete_if.each{|i| i.even?}).to eq(List[1,3])
-    expect(list.delete_if{|i| 0 < i}).to eq(List[])
-    expect(list.delete_if{|i| 0 < i}).to eq(List[])
-    expect(list).to eq(List[])
+    list = @cls[1,2,3,4,5]
+    expect(list.delete_if{|i| 3 < i}).to eq(@cls[1,2,3])
+    expect(list.delete_if.each{|i| i.even?}).to eq(@cls[1,3])
+    expect(list.delete_if{|i| 0 < i}).to eq(@cls[])
+    expect(list.delete_if{|i| 0 < i}).to eq(@cls[])
+    expect(list).to eq(@cls[])
   end
 
   it "reject" do
-    list = List[1,2,3,4,5]
-    expect(list.reject{|i| 3 < i}).to eq(List[1,2,3])
-    expect(list.reject.each{|i| i.even?}).to eq(List[1,3,5])
-    expect(list.reject{|i| 0 < i}).to eq(List[])
-    expect(list).to eq(List[1,2,3,4,5])
+    list = @cls[1,2,3,4,5]
+    expect(list.reject{|i| 3 < i}).to eq(@cls[1,2,3])
+    expect(list.reject.each{|i| i.even?}).to eq(@cls[1,3,5])
+    expect(list.reject{|i| 0 < i}).to eq(@cls[])
+    expect(list).to eq(@cls[1,2,3,4,5])
   end
 
   it "reject!" do
-    list = List[1,2,3,4,5]
+    list = @cls[1,2,3,4,5]
     expect(list.reject!{|i| i % 10 == 0}).to eq(nil)
-    expect(list.reject!{|i| 3 < i}).to eq(List[1,2,3])
-    expect(list.reject!.each{|i| i.even?}).to eq(List[1,3])
-    expect(list.reject!{|i| 0 < i}).to eq(List[])
+    expect(list.reject!{|i| 3 < i}).to eq(@cls[1,2,3])
+    expect(list.reject!.each{|i| i.even?}).to eq(@cls[1,3])
+    expect(list.reject!{|i| 0 < i}).to eq(@cls[])
     expect(list.reject!{|i| 0 < i}).to eq(nil)
-    expect(list).to eq(List[])
+    expect(list).to eq(@cls[])
   end
 
   it "zip" do
-    a = List[4,5,6]
-    b = List[7,8,9]
+    a = @cls[4,5,6]
+    b = @cls[7,8,9]
     ary = []
-    expect(a.zip(b)).to eq(List[List[4,7],List[5,8],List[6,9]])
-    expect(List[1,2,3].zip(a,b)).to eq(List[List[1,4,7],List[2,5,8],List[3,6,9]])
-    expect(List[1,2].zip(a,b)).to eq(List[List[1,4,7],List[2,5,8]])
-    expect(a.zip(List[1,2],List[8])).to eq(List[List[4,1,8],List[5,2,nil],List[6,nil,nil]])
-    expect(a.zip([1,2],[8])).to eq(List[List[4,1,8],List[5,2,nil],List[6,nil,nil]])
+    expect(a.zip(b)).to eq(@cls[[4,7],[5,8],[6,9]])
+    expect(@cls[1,2,3].zip(a,b)).to eq(@cls[[1,4,7],[2,5,8],[3,6,9]])
+    expect(@cls[1,2].zip(a,b)).to eq(@cls[[1,4,7],[2,5,8]])
+    expect(a.zip(@cls[1,2],@cls[8])).to eq(@cls[[4,1,8],[5,2,nil],[6,nil,nil]])
+    expect(a.zip([1,2],[8])).to eq(@cls[[4,1,8],[5,2,nil],[6,nil,nil]])
     expect(a.zip([1,2],[8]){|i| ary << i}).to eq(nil)
-    expect(ary).to eq([List[4,1,8],List[5,2,nil],List[6,nil,nil]])
+    expect(ary).to eq([[4,1,8],[5,2,nil],[6,nil,nil]])
     expect{a.zip("a")}.to raise_error  # <= 1.9.3 NoMethodError, >= 2.0.0 TypeError
+    
+    obj = Object.new
+    def obj.to_a; [1,2]; end
+    expect{@cls[*%w{a b}].zip(obj)}.to raise_error # <= 1.9.3 NoNameError, >= 2.0.0 TypeError
+
+    def obj.each; [3,4].each{|e| yield e}; end
+    expect(@cls[*%w{a b}].zip(obj)).to eq(@cls[['a',3],['b',4]])
+
+    def obj.to_ary; [5,6]; end
+    expect(@cls[*%w{a b}].zip(obj)).to eq(@cls[['a',5],['b',6]])
+
+    r = 1..1
+    def r.respond_to?(*); super; end
+    expect(@cls[42].zip(r)).to eq(@cls[[42,1]])
   end
 
   it "transpose" do
-    expect(List[].transpose).to eq(List[])
-    expect(List[List[1,2],List[3,4],List[5,6]].transpose).to eq(List[List[1,3,5],List[2,4,6]])
-    expect(List[[1,2],[3,4],[5,6]].transpose).to eq(List[List[1,3,5],List[2,4,6]])
-    expect{List[[1],[2,3]].transpose}.to raise_error(IndexError)
-    expect{List[1].transpose}.to raise_error(TypeError)
+    expect(@cls[].transpose).to eq(@cls[])
+    expect(@cls[[1,2],@cls[3,4],@cls[5,6]].transpose).to eq(@cls[[1,3,5],[2,4,6]])
+    expect(@cls[[1,2],[3,4],[5,6]].transpose).to eq(@cls[[1,3,5],[2,4,6]])
+    expect{@cls[[1],[2,3]].transpose}.to raise_error(IndexError)
+    expect{@cls[1].transpose}.to raise_error(TypeError)
   end
 
   it "fill" do
-    list = List["a","b","c","d"]
-    expect(list.fill("x")).to eq(List["x","x","x","x"])
-    expect(list.fill("z",2,2)).to eq(List["x","x","z","z"])
-    expect(list.fill("y",0..1)).to eq(List["y","y","z","z"])
-    expect(list.fill{"foo"}).to eq(List["foo","foo","foo","foo"])
+    list = @cls["a","b","c","d"]
+    expect(list.fill("x")).to eq(@cls["x","x","x","x"])
+    expect(list.fill("z",2,2)).to eq(@cls["x","x","z","z"])
+    expect(list.fill("y",0..1)).to eq(@cls["y","y","z","z"])
+    expect(list.fill{"foo"}).to eq(@cls["foo","foo","foo","foo"])
     expect(list[0].object_id).to_not eq(list[1].object_id)
-    expect(list.fill{|i| i*i}).to eq(List[0,1,4,9])
-    expect(list.fill(-2){|i| i*i*i}).to eq(List[0,1,8,27])
-    expect(list.fill("z",2)).to eq(List[0,1,"z","z"])
+    expect(list.fill{|i| i*i}).to eq(@cls[0,1,4,9])
+    expect(list.fill(-2){|i| i*i*i}).to eq(@cls[0,1,8,27])
+    expect(list.fill("z",2)).to eq(@cls[0,1,"z","z"])
     expect{list.fill("z","a")}.to raise_error(TypeError)
   end
 
   it "include?" do
-    list = List.new
+    list = @cls.new
     expect(list.include?(1)).to eq(false)
     list.push 1,2,3
     expect(list.include?(1)).to eq(true)
@@ -597,28 +657,28 @@ describe List do
   end
 
   it "<=>" do
-    expect(List["a","a","c"] <=> List["a","b","c"]).to eq(-1)
-    expect(List[1,2,3,4,5,6] <=> List[1,2]).to eq(+1)
-    expect(List[1,2] <=> List[1,2]).to eq(0)
-    expect(List[1,2] <=> List[1,:two]).to eq(nil)
+    expect(@cls["a","a","c"] <=> @cls["a","b","c"]).to eq(-1)
+    expect(@cls[1,2,3,4,5,6] <=> @cls[1,2]).to eq(+1)
+    expect(@cls[1,2] <=> @cls[1,2]).to eq(0)
+    expect(@cls[1,2] <=> @cls[1,:two]).to eq(nil)
   end
 
   it "slice" do
-    list = List.new
+    list = @cls.new
     expect(list.slice(0)).to eq(nil)
     list.push 1,2,3,4,5
     expect(list.slice(0)).to eq(1)
-    expect(list.slice(1,3)).to eq(List[2,3,4])
-    expect(list.slice(1..3)).to eq(List[2,3,4])
+    expect(list.slice(1,3)).to eq(@cls[2,3,4])
+    expect(list.slice(1..3)).to eq(@cls[2,3,4])
   end
 
   it "slice!" do
-    list = List.new
+    list = @cls.new
     expect(list.slice!(0)).to eq(nil)
     list.push 1,2,3,4,5
     expect(list.slice!(2)).to eq(3)
-    expect(list.slice!(2,3)).to eq(List[4,5])
-    expect(list.slice!(0..1)).to eq(List[1,2])
+    expect(list.slice!(2,3)).to eq(@cls[4,5])
+    expect(list.slice!(0..1)).to eq(@cls[1,2])
     list.push 1,2,3,4,5
     expect(list.slice!(-1)).to eq(5)
     expect(list.slice!(100..110)).to eq(nil)
@@ -628,13 +688,500 @@ describe List do
     expect{list.slice!("a")}.to raise_error(TypeError)
     expect{list.slice!(1,"a")}.to raise_error(TypeError)
     expect{list.slice!(1,2,3)}.to raise_error(ArgumentError)
-    expect(list).to eq(List[1,2,3,4])
+    expect(list).to eq(@cls[1,2,3,4])
+  end
+
+  it "assoc" do
+    expect(@cls[].assoc "foo").to eq(nil)
+    list = @cls[@cls["foo",1,2],["bar",1,2],[1,"baz"]]
+    expect(list.assoc "foo").to eq(@cls["foo",1,2])
+    expect(list.assoc "bar").to eq(@cls["bar",1,2])
+    expect(list.assoc "baz").to eq(nil)
+  end
+
+  it "rassoc" do
+    expect(@cls[].rassoc "foo").to eq(nil)
+    list = @cls[@cls["foo",1,2],["bar",1,2],[1,"baz"]]
+    expect(list.rassoc "foo").to eq(nil)
+    expect(list.rassoc 1).to eq(@cls["foo",1,2])
+    expect(list.rassoc "baz").to eq(@cls[1,"baz"])
+  end
+
+  it "+" do
+    expect(@cls[] + @cls[]).to eq(@cls[])
+    expect(@cls[1] + @cls[]).to eq(@cls[1])
+    expect(@cls[] + @cls[1]).to eq(@cls[1])
+    expect(@cls[1] + @cls[1]).to eq(@cls[1,1])
+    expect(@cls[1] + @subcls[1]).to eq(@cls[1,1])
+    expect(@subcls[1] + @cls[1]).to eq(@subcls[1,1])
+    expect(@cls[1,2,3] + @cls["a","b","c"]).to eq(@cls[1,2,3,"a","b","c"])
+    expect{@cls[] + 1}.to raise_error(TypeError)
+  end
+
+  it "*" do
+    expect(@cls[] * 3).to eq(@cls[])
+    expect(@cls[1] * 3).to eq(@cls[1,1,1])
+    expect(@cls[1,2] * 3).to eq(@cls[1,2,1,2,1,2])
+    expect(@cls[1,2,3] * 0).to eq(@cls[])
+    expect{@cls[1,2,3] * (-3)}.to raise_error(ArgumentError)
+
+    expect(@cls[1,2,3] * "-").to eq("1-2-3")
+    expect(@cls[1,2,3] * "").to eq("123")
+  end
+
+  it "-" do
+    expect(@cls[1] - @cls[1]).to eq(@cls[])
+    expect(@cls[1,2,3,4,5] - @cls[2,3,4,5]).to eq(@cls[1])
+    expect(@cls[1,2,1,3,1,4,1,5] - @cls[2,3,4,5]).to eq(@cls[1,1,1,1])
+    list = @cls[]
+    1000.times { list << 1 }
+    expect(list - @cls[2]).to eq(@cls[1] * 1000)
+    expect(@cls[1,2,1] - @cls[2]).to eq(@cls[1,1])
+    expect(@cls[1,2,3] - @cls[4,5,6]).to eq(@cls[1,2,3])
+  end
+
+  it "&" do
+    expect(@cls[1,1,3,5] & @cls[1,2,3]).to eq(@cls[1,3])
+    expect(@cls[1,1,3,5] & @cls[]).to eq(@cls[])
+    expect(@cls[] & @cls[1,2,3]).to eq(@cls[])
+    expect(@cls[1,2,3] & @cls[4,5,6]).to eq(@cls[])
+  end
+
+  it "|" do
+    expect(@cls[ ] | @cls[ ]).to eq(@cls[ ])
+    expect(@cls[ ] | @cls[1]).to eq(@cls[1])
+    expect(@cls[1] | @cls[ ]).to eq(@cls[1])
+    expect(@cls[1] | @cls[1]).to eq(@cls[1])
+
+    expect(@cls[1] | @cls[2]).to eq(@cls[1,2])
+    expect(@cls[1,1] | @cls[2,2]).to eq(@cls[1,2])
+    expect(@cls[1,2] | @cls[1,2]).to eq(@cls[1,2])
+
+    a = @cls[*%w{a b c}]
+    b = @cls[*%w{a b c d e}]
+    c = a | b
+    expect(b).to eq(c)
+    expect(b.eql?(c)).to eq false
+  end
+
+  it "uniq" do
+    a = @cls[]
+    b = a.uniq
+    expect(a).to eq(@cls[])
+    expect(b).to eq(@cls[])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1]
+    b = a.uniq
+    expect(a).to eq(@cls[1])
+    expect(b).to eq(@cls[1])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1,1]
+    b = a.uniq
+    expect(a).to eq(@cls[1,1])
+    expect(b).to eq(@cls[1])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1,2]
+    b = a.uniq
+    expect(a).to eq(@cls[1,2])
+    expect(b).to eq(@cls[1,2])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1,2,3,2,1,2,3,4,nil]
+    b = a.dup
+    expect(a.uniq).to eq(@cls[1,2,3,4,nil])
+    expect(a).to eq(b)
+
+    c = @cls["a:def","a:xyz","b:abc","b:xyz","c:jkl"]
+    d = c.dup
+    expect(c.uniq{|s| s[/^\w+/]}).to eq(@cls["a:def","b:abc","c:jkl"])
+    expect(c).to eq(d)
+
+    a = @cls[*%w{a a}]
+    b = a.uniq
+    expect(a).to eq(@cls[*%w{a a}])
+    expect(a.none?(&:frozen?)).to eq true 
+    expect(b).to eq(@cls[*%w{a}])
+    expect(b.none?(&:frozen?)).to eq true
+
+    b = "abc"
+    list = @cls[b,b.dup,b.dup]
+    expect(list.uniq.size).to eq(1)
+    expect(list.uniq[0]).to eq(b)
+
+    a = @cls[]
+    b = a.uniq {|v| v.even? }
+    expect(a).to eq(@cls[])
+    expect(b).to eq(@cls[])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1]
+    b = a.uniq {|v| v.even? }
+    expect(a).to eq(@cls[1])
+    expect(b).to eq(@cls[1])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[1,3]
+    b = a.uniq {|v| v.even? }
+    expect(a).to eq(@cls[1,3])
+    expect(b).to eq(@cls[1])
+    expect(a.eql?(b)).to eq false
+
+    a = @cls[*%w{a a}]
+    b = a.uniq {|v| v }
+    expect(a).to eq(@cls[*%w{a a}])
+    expect(a.none?(&:frozen?)).to eq true 
+    expect(b).to eq(@cls[*%w{a}])
+    expect(b.none?(&:frozen?)).to eq true
+  end
+
+  it "uniq!" do
+    a = @cls[]
+    b = a.uniq!
+    expect(b).to eq(nil)
+
+    a = @cls[1]
+    b = a.uniq!
+    expect(b).to eq(nil)
+
+    a = @cls[1,1]
+    b = a.uniq!
+    expect(a).to eq(@cls[1])
+    expect(b).to eq(@cls[1])
+    expect(b).to eq(a)
+
+    a = @cls[1,2]
+    b = a.uniq!
+    expect(a).to eq(@cls[1,2])
+    expect(b).to eq(nil)
+
+    a = @cls[1,2,3,2,1,2,3,4,nil]
+    expect(a.uniq!).to eq(@cls[1,2,3,4,nil])
+    expect(a).to eq(@cls[1,2,3,4,nil])
+
+    c = @cls["a:def","a:xyz","b:abc","b:xyz","c:jkl"]
+    d = c.dup
+    expect(c.uniq!{|s| s[/^\w+/]}).to eq(@cls["a:def","b:abc","c:jkl"])
+    expect(c).to eq(@cls["a:def","b:abc","c:jkl"])
+
+    c = @cls["a:def","b:abc","c:jkl"]
+    expect(c.uniq!{|s| s[/^\w+/]}).to eq(nil)
+    expect(c).to eq(@cls["a:def","b:abc","c:jkl"])
+
+    expect(@cls[1,2,3].uniq!).to eq(nil)
+
+    f = a.dup.freeze
+    expect{a.uniq!(1)}.to raise_error(ArgumentError)
+    expect{f.uniq!(1)}.to raise_error(ArgumentError)
+    expect{f.uniq!}.to raise_error(RuntimeError)
+
+    expect{
+      a = @cls[ {c: "b"}, {c: "r"}, {c: "w"}, {c: "g"}, {c: "g"} ]
+      a.sort_by!{|e| e[:c]}
+      a.uniq!   {|e| e[:c]}
+    }.to_not raise_error
+
+    a = @cls[]
+    b = a.uniq! {|v| v.even? }
+    expect(b).to eq(nil)
+
+    a = @cls[1]
+    b = a.uniq! {|v| v.even? }
+    expect(b).to eq(nil)
+
+    a = @cls[1,3]
+    b = a.uniq! {|v| v.even? }
+    expect(a).to eq(@cls[1])
+    expect(b).to eq(@cls[1])
+    expect(a.eql?(b)).to eq true
+
+    a = @cls[*%w{a a}]
+    b = a.uniq! {|v| v }
+    expect(b).to eq(@cls[*%w{a}])
+    expect(a.eql?(b)).to eq true
+    expect(b.none?(&:frozen?)).to eq true
+
+    list = @cls[1,2]
+    orig = list.dup
+    expect{list.uniq! {|v| list.freeze; 1}}.to raise_error(RuntimeError)
+    expect(list).to eq(orig)
+  end
+
+  it "compact" do
+    expect(@cls[1,nil,nil,2,3,nil,4].compact).to eq(@cls[1,2,3,4])
+    expect(@subcls[1,nil,nil,2,3,nil,4].compact).to eq(@subcls[1,2,3,4])
+    expect(@cls[nil,1,nil,2,3,nil,4].compact).to eq(@cls[1,2,3,4])
+    expect(@cls[1,nil,nil,2,3,nil,4,nil].compact).to eq(@cls[1,2,3,4])
+    expect(@cls[1,2,3,4].compact).to eq(@cls[1,2,3,4])
+  end
+
+  it "compact!" do
+    a = @cls[1,nil,nil,2,3,nil,4]
+    expect(a.compact!).to eq(@cls[1,2,3,4])
+    expect(a).to eq(@cls[1,2,3,4])
+
+    a = @cls[nil,1,nil,2,3,nil,4]
+    expect(a.compact!).to eq(@cls[1,2,3,4])
+    expect(a).to eq(@cls[1,2,3,4])
+
+    a = @cls[1,nil,nil,2,3,nil,4,nil]
+    expect(a.compact!).to eq(@cls[1,2,3,4])
+    expect(a).to eq(@cls[1,2,3,4])
+
+    a = @cls[1,2,3,4]
+    expect(a.compact!).to eq(nil)
+    expect(a).to eq(@cls[1,2,3,4])
+  end
+
+  it "flatten" do
+    a1 = @cls[1,2,3]
+    a2 = @cls[5,6]
+    a3 = @cls[4,a2]
+    a4 = @cls[a1,a3]
+    expect(a4.flatten).to eq(@cls[1,2,3,4,5,6])
+    expect(a4.flatten(1)).to eq(@cls[1,2,3,4,@cls[5,6]])
+    expect(a4).to eq(@cls[a1,a3])
+
+    a5 = @cls[a1,@cls[],a3]
+    expect(a5.flatten).to eq(@cls[1,2,3,4,5,6])
+    expect(@cls[].flatten).to eq(@cls[])
+    expect(@cls[@cls[@cls[@cls[],@cls[]],@cls[@cls[]],@cls[]],@cls[@cls[@cls[]]]].flatten).to eq(@cls[])
+
+    expect{@cls[@cls[]].flatten("")}.to raise_error(TypeError)
+
+    a6 = @cls[@cls[1,2],3]
+    a6.taint
+    a7 = a6.flatten
+    expect(a7.tainted?).to eq true
+
+    a8 = @cls[@cls[1,2],3]
+    a9 = a8.flatten(0)
+    expect(a9).to eq(a8)
+    expect(a9.eql?(a8)).to eq false
+
+    f = [].freeze
+    expect{f.flatten!(1,2)}.to raise_error(ArgumentError)
+    expect{f.flatten!}.to raise_error(RuntimeError)
+    expect{f.flatten!(:foo)}.to raise_error(RuntimeError)
+  end
+
+  it "flatten!" do
+    a1 = @cls[1,2,3]
+    a2 = @cls[5,6]
+    a3 = @cls[4,a2]
+    a4 = @cls[a1,a3]
+    expect(a4.flatten!).to eq(@cls[1,2,3,4,5,6])
+    expect(a4).to eq(@cls[1,2,3,4,5,6])
+
+    a5 = @cls[a1,@cls[],a3]
+    expect(a5.flatten!).to eq(@cls[1,2,3,4,5,6])
+    expect(a5.flatten!(0)).to eq(nil)
+    expect(a5).to eq(@cls[1,2,3,4,5,6])
+
+    expect(@cls[].flatten!).to eq(nil)
+    expect(@cls[@cls[@cls[@cls[],@cls[]],@cls[@cls[]],@cls[]],@cls[@cls[@cls[]]]].flatten!).to eq(@cls[])
+
+    expect(@cls[].flatten!(0)).to eq(nil)
+  end
+
+  it "count" do
+    a = @cls[1,2,3,1,2]
+    expect(a.count).to eq(5)
+    expect(a.count(1)).to eq(2)
+    expect(a.count {|x| x % 2 == 1}).to eq(3)
+    expect(a.count(1) {|x| x % 2 == 1}).to eq(2)
+    expect{a.count(0,1)}.to raise_error(ArgumentError)
+  end
+
+  it "shuffle" do
+    100.times do
+      expect(@cls[2,1,0].shuffle.sort).to eq(@cls[0,1,2])
+    end
+
+    gen = Random.new(0)
+    expect{@cls[1,2,3].shuffle(1, random: gen)}.to raise_error(ArgumentError)
+    srand(0)
+    100.times do
+      expect(@cls[0,1,2].shuffle(random: gen)).to eq(@cls[0,1,2].shuffle)
+    end
+
+    # FIXME v1.9.3 and v2.0.0 nothing raise
+    # expect{@cls[0,1,2].shuffle(xawqij: "a")}.to raise_error(ArgumentError)
+    # expect{@cls[0,1,2].shuffle!(xawqij: "a")}.to raise_error(ArgumentError)
+
+    gen = proc do
+      10000000
+    end
+    class << gen
+      alias rand call
+    end
+    expect{@cls[*0..2].shuffle(random: gen)}.to raise_error(RangeError)
+
+    # FIXME
+    # list = @cls[*(0...10000)]
+    # gen = proc do
+    #   list.replace(@cls[])
+    #   0.5
+    # end
+    # class << gen
+    #   alias rand call
+    # end
+    # expect{list.shuffle!(random: gen)}.to raise_error(RuntimeError)
+
+    # zero = Object.new
+    # def zero.to_int
+    #   0
+    # end
+    # gen_to_int = proc do |max|
+    #   zero
+    # end
+    # class << gen_to_int
+    #   alias rand call
+    # end
+    # list = @cls[*(0...10000)]
+    # expect(list.shuffle(random: gen_to_int)).to eq(list.rotate)
+  end
+
+  it "sample" do
+    100.times do
+      s = [2,1,0].sample
+      expect(s).to be_a_kind_of(Fixnum)
+      expect(s).to be >= 0
+      expect(s).to be <= 2
+      @cls[2,1,0].sample(2).each {|sample|
+        expect(sample).to be_a_kind_of(Fixnum)
+        expect(sample).to be >= 0
+        expect(sample).to be <= 2
+      }
+    end
+
+    srand(0)
+    a = @cls[*1..18]
+    (0..20).each do |n|
+      100.times do
+        b = a.sample(n)
+        expect(b.size).to eq([n,18].min)
+        expect((a | b).sort).to eq(a)
+        expect((a & b).sort).to eq(b.sort)
+      end
+
+      h = Hash.new(0)
+      1000.times do
+        a.sample(n).each {|x| h[x] += 1 }
+      end
+      expect(h.values.max).to be <= (h.values.min * 2) if n != 0
+    end
+
+    expect{[1,2].sample(-1)}.to raise_error(ArgumentError)
+  
+    gen = Random.new(0)
+    srand(0)
+    a = @cls[*(1..18)]
+    (0..20).each do |n|
+      100.times do |i|
+        expect(a.sample(n, random: gen)).to eq(a.sample(n))
+      end
+    end
+
+    # FIXME v1.9.3 and v2.0.0 nothing raise
+    # expect{@cls[0,1,2].sample(xawqij: "a")}.to raise_error(ArgumentError)
+  end
+
+  it "cycle" do
+    a = @cls[]
+    @cls[0,1,2].cycle do |i|
+      a << i
+      break if a.size == 10
+    end
+    expect(a).to eq(@cls[0,1,2,0,1,2,0,1,2,0])
+
+    a = @cls[0,1,2]
+    expect(a.cycle {a.clear}).to eq(nil)
+
+    a = @cls[]
+    @cls[0,1,2].cycle(3) {|i| a << i}
+    expect(a).to eq(@cls[0,1,2,0,1,2,0,1,2])
+
+    expect(@cls[0,1,2].cycle(3).to_a.size).to eq(9)
+
+    expect(@cls[0,1,2].cycle(-1){}).to eq(nil)
+    expect{@cls[0,1,2].cycle("a"){}}.to raise_error(TypeError)
+  end
+
+  it "permutation" do
+    a = @cls[1,2,3]
+    expect(a.permutation(0).to_list).to eq(@cls[[]])
+    expect(a.permutation(1).to_list.sort).to eq(@cls[[1],[2],[3]])
+    expect(a.permutation(2).to_list.sort).to eq(@cls[[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]])
+  end
+
+  it "compatible" do
+    expect(@cls[1,2,3,4].combination(0).to_list).to eq(@cls[[]])
+    expect(@cls[1,2,3,4].combination(1).to_list).to eq(@cls[[1],[2],[3],[4]])
+    expect(@cls[1,2,3,4].combination(2).to_list).to eq(@cls[[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]])
+  end
+
+  it "repeated_combination" do
+    a = @cls[1,2,3]
+    expect(a.repeated_combination(0).to_list).to eq(@cls[[]])
+    expect(a.repeated_combination(1).to_list.sort).to eq(@cls[[1],[2],[3]])
+    expect(a.repeated_combination(2).to_list.sort).to eq(@cls[[1,1],[1,2],[1,3],[2,2],[2,3],[3,3]])
+  end
+
+  it "repeated_permutation" do
+    a = @cls[1,2]
+    expect(a.repeated_permutation(0).to_list).to eq(@cls[[]])
+    expect(a.repeated_permutation(1).to_list.sort).to eq(@cls[[1],[2]])
+    expect(a.repeated_permutation(2).to_list.sort).to eq(@cls[[1,1],[1,2],[2,1],[2,2]])
+  end
+
+  it "product" do
+    expect(@cls[1,2,3].product([4,5])).to eq(@cls[[1,4],[1,5],[2,4],[2,5],[3,4],[3,5]])
+    expect(@cls[1,2].product([1,2])).to eq(@cls[[1,1],[1,2],[2,1],[2,2]])
+    expect(@subcls[1,2].product([1,2])).to eq(@subcls[[1,1],[1,2],[2,1],[2,2]])
+  end
+
+  it "take" do
+    expect(@cls[1,2,3,4,5,0].take(3)).to eq(@cls[1,2,3])
+    expect(@subcls[1,2,3,4,5,0].take(3)).to eq(@subcls[1,2,3])
+    expect{@cls[1,2].take(-1)}.to raise_error(ArgumentError)
+    expect(@cls[1,2].take(1000000000)).to eq(@cls[1,2])
+  end
+
+  it "take_while" do
+    expect(@cls[1,2,3,4,5,0].take_while {|i| i < 3}).to eq(@cls[1,2])
+  end
+
+  it "drop" do
+    expect(@cls[1,2,3,4,5,0].drop(3)).to eq(@cls[4,5,0])
+    expect{@cls[1,2].drop(-1)}.to raise_error(ArgumentError)
+    expect(@cls[1,2].drop(1000000000)).to eq(@cls[])
+  end
+
+  it "drop_while" do
+    expect(@cls[1,2,3,4,5,0].drop_while {|i| i < 3 }).to eq(@cls[3,4,5,0])
+    expect(@subcls[1,2,3,4,5,0].drop_while {|i| i < 3 }).to eq(@subcls[3,4,5,0])
+  end
+
+  it "bsearch" do
+    expect{@cls[1, 2, 42, 100, 666].bsearch{ "not ok" }}.to raise_error(TypeError)
+    expect(@cls[1, 2, 42, 100, 666].bsearch{false}).to eq(@cls[1, 2, 42, 100, 666].bsearch{})
+    enum = @cls[1, 2, 42, 100, 666].bsearch
+    if enum.respond_to? :size # v1.9.3 not respond to :size
+      expect(enum.size).to eq nil
+    end
+    expect(enum.each{|x| x >= 33}).to eq(42)
+
+    a = @cls[0,4,7,10,12]
+    expect(a.bsearch {|x| 4 - x / 2 }).to eq nil
   end
 
   it "ring" do
     len = 0
     result = []
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     ring = list.ring
     ring.each do |i|
       break if len == 1000
@@ -649,7 +1196,7 @@ describe List do
   it "ring!" do
     len = 0
     result = []
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     ring = list.ring!
     ring.each do |i|
       break if len == 1000
@@ -662,7 +1209,7 @@ describe List do
   end
 
   it "ring?" do
-    list = List[1,2,3]
+    list = @cls[1,2,3]
     expect(list.ring?).to eq(false)
     expect(list.ring.ring?).to eq(true)
     expect(list.ring!.ring?).to eq(true)