immutable-ruby 0.0.1 → 0.1.0

data/spec/lib/immutable/hash/fetch_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#fetch" do
-    context "with no default provided" do
-      context "when the key exists" do
-        it "returns the value associated with the key" do
-          H["A" => "aye"].fetch("A").should == "aye"
-        end
-      end
-
-      context "when the key does not exist" do
-        it "raises a KeyError" do
-          -> { H["A" => "aye"].fetch("B") }.should raise_error(KeyError)
-        end
-      end
-    end
-
-    context "with a default value" do
-      context "when the key exists" do
-        it "returns the value associated with the key" do
-          H["A" => "aye"].fetch("A", "default").should == "aye"
-        end
-      end
-
-      context "when the key does not exist" do
-        it "returns the default value" do
-          H["A" => "aye"].fetch("B", "default").should == "default"
-        end
-      end
-    end
-
-    context "with a default block" do
-      context "when the key exists" do
-        it "returns the value associated with the key" do
-          H["A" => "aye"].fetch("A") { "default".upcase }.should == "aye"
-        end
-      end
-
-      context "when the key does not exist" do
-        it "invokes the default block with the missing key as paramter" do
-          H["A" => "aye"].fetch("B") { |key| key.should == "B" }
-          H["A" => "aye"].fetch("B") { "default".upcase }.should == "DEFAULT"
-        end
-      end
-    end
-
-    it "gives precedence to default block over default argument if passed both" do
-      H["A" => "aye"].fetch("B", 'one') { 'two' }.should == 'two'
-    end
-
-    it "raises an ArgumentError when not passed one or 2 arguments" do
-      -> { H.empty.fetch }.should raise_error(ArgumentError)
-      -> { H.empty.fetch(1, 2, 3) }.should raise_error(ArgumentError)
-    end
-  end
-end

data/spec/lib/immutable/hash/find_spec.rb

@@ -1,43 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:find, :detect].each do |method|
-    describe "##{method}" do
-      [
-        [[], "A", nil],
-        [[], nil, nil],
-        [["A" => "aye"], "A", ["A", "aye"]],
-        [["A" => "aye"], "B", nil],
-        [["A" => "aye"], nil, nil],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "A", ["A", "aye"]],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "B", ["B", "bee"]],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], nil, [nil, "NIL"]],
-        [["A" => "aye", "B" => "bee", nil => "NIL"], "C", nil],
-      ].each do |values, key, expected|
-        describe "on #{values.inspect}" do
-          let(:hash) { H[*values] }
-
-          describe "with a block" do
-            it "returns #{expected.inspect}" do
-              hash.send(method) { |k, v| k == key }.should == expected
-            end
-          end
-
-          describe "without a block" do
-            it "returns an Enumerator" do
-              result = hash.send(method)
-              result.class.should be(Enumerator)
-              result.each { |k,v| k == key }.should == expected
-            end
-          end
-        end
-      end
-
-      it "stops iterating when the block returns true" do
-        yielded = []
-        H[a: 1, b: 2].find { |k,v| yielded << k; true }
-        yielded.size.should == 1
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/flat_map_spec.rb

@@ -1,35 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-  describe "#flat_map" do
-    it "yields each key/val pair" do
-      passed = []
-      hash.flat_map { |pair| passed << pair }
-      passed.sort.should == [['A', 'aye'], ['B', 'bee'], ['C', 'see']]
-    end
-
-    it "returns the concatenation of block return values" do
-      hash.flat_map { |k,v| [k,v] }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
-      hash.flat_map { |k,v| L[k,v] }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
-      hash.flat_map { |k,v| V[k,v] }.sort.should == ['A', 'B', 'C', 'aye', 'bee', 'see']
-    end
-
-    it "doesn't change the receiver" do
-      hash.flat_map { |k,v| [k,v] }
-      hash.should eql(H["A" => "aye", "B" => "bee", "C" => "see"])
-    end
-
-    context "with no block" do
-      it "returns an Enumerator" do
-        hash.flat_map.class.should be(Enumerator)
-        hash.flat_map.each { |k,v| [k] }.sort.should == ['A', 'B', 'C']
-      end
-    end
-
-    it "returns an empty array if only empty arrays are returned by block" do
-      hash.flat_map { [] }.should eql([])
-    end
-  end
-end

data/spec/lib/immutable/hash/flatten_spec.rb

@@ -1,98 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#flatten" do
-    context "with flatten depth of zero" do
-      it "returns a vector of keys/value" do
-        hash = H[a: 1, b: 2]
-        hash.flatten(0).sort.should eql(V[[:a, 1], [:b, 2]])
-      end
-    end
-
-    context "without array keys or values" do
-      it "returns a vector of keys and values" do
-        hash = H[a: 1, b: 2, c: 3]
-        possibilities = [[:a, 1, :b, 2, :c, 3],
-         [:a, 1, :c, 3, :b, 2],
-         [:b, 2, :a, 1, :c, 3],
-         [:b, 2, :c, 3, :a, 1],
-         [:c, 3, :a, 1, :b, 2],
-         [:c, 3, :b, 2, :a, 1]]
-        possibilities.include?(hash.flatten).should == true
-        possibilities.include?(hash.flatten(1)).should == true
-        possibilities.include?(hash.flatten(2)).should == true
-        hash.flatten(2).class.should be(Immutable::Vector)
-        possibilities.include?(hash.flatten(10)).should == true
-      end
-
-      it "doesn't modify the receiver" do
-        hash = H[a: 1, b: 2, c: 3]
-        hash.flatten(1)
-        hash.flatten(2)
-        hash.should eql(H[a: 1, b: 2, c: 3])
-      end
-    end
-
-    context "on an empty Hash" do
-      it "returns an empty Vector" do
-        H.empty.flatten.should eql(V.empty)
-      end
-    end
-
-    context "with array keys" do
-      it "flattens array keys into returned vector if flatten depth is sufficient" do
-        hash = H[[1, 2] => 3, [4, 5] => 6]
-        [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten(1)).should == true
-        [[[1, 2], 3, [4, 5], 6], [[4, 5], 6, [1, 2], 3]].include?(hash.flatten).should == true
-        hash.flatten(1).class.should be(Immutable::Vector)
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
-      end
-
-      it "doesn't modify the receiver (or its contents)" do
-        hash = H[[1, 2] => 3, [4, 5] => 6]
-        hash.flatten(1)
-        hash.flatten(2)
-        hash.should eql(H[[1, 2] => 3, [4, 5] => 6])
-      end
-    end
-
-    context "with array values" do
-      it "flattens array values into returned vector if flatten depth is sufficient" do
-        hash = H[1 => [2, 3], 4 => [5, 6]]
-        [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten(1)).should == true
-        [[1, [2, 3], 4, [5, 6]], [4, [5, 6], 1, [2, 3]]].include?(hash.flatten).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
-        hash.flatten(3).class.should be(Immutable::Vector)
-      end
-
-      it "doesn't modify the receiver (or its contents)" do
-        hash = H[1 => [2, 3], 4 => [5, 6]]
-        hash.flatten(1)
-        hash.flatten(2)
-        hash.should eql(H[1 => [2, 3], 4 => [5, 6]])
-      end
-    end
-
-    context "with vector keys" do
-      it "flattens vector keys into returned vector if flatten depth is sufficient" do
-        hash = H[V[1, 2] => 3, V[4, 5] => 6]
-        [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten).should == true
-        [[V[1, 2], 3, V[4, 5], 6], [V[4, 5], 6, V[1, 2], 3]].include?(hash.flatten(1)).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
-      end
-    end
-
-    context "with vector values" do
-      it "flattens vector values into returned vector if flatten depth is sufficient" do
-        hash = H[1 => V[2, 3], 4 => V[5, 6]]
-        [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten(1)).should == true
-        [[1, V[2, 3], 4, V[5, 6]], [4, V[5, 6], 1, V[2, 3]]].include?(hash.flatten).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(2)).should == true
-        [[1, 2, 3, 4, 5, 6], [4, 5, 6, 1, 2, 3]].include?(hash.flatten(3)).should == true
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/get_spec.rb

@@ -1,79 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:get, :[]].each do |method|
-    describe "##{method}" do
-      context "with a default block" do
-        let(:hash) { H.new("A" => "aye") { |key| fail }}
-
-        context "when the key exists" do
-          it "returns the value associated with the key" do
-            hash.send(method, "A").should == "aye"
-          end
-
-          it "does not call the default block even if the key is 'nil'" do
-            H.new(nil => 'something') { fail }.send(method, nil)
-          end
-        end
-
-        context "when the key does not exist" do
-          let(:hash) do
-            H.new("A" => "aye") do |key|
-              expect(key).to eq("B")
-              "bee"
-            end
-          end
-
-          it "returns the value from the default block" do
-            hash.send(method, "B").should == "bee"
-          end
-        end
-      end
-
-      context "with no default block" do
-        let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL"] }
-
-        [
-          %w[A aye],
-          %w[B bee],
-          %w[C see],
-          [nil, "NIL"]
-        ].each do |key, value|
-          it "returns the value (#{value.inspect}) for an existing key (#{key.inspect})" do
-            hash.send(method, key).should == value
-          end
-        end
-
-        it "returns nil for a non-existing key" do
-          hash.send(method, "D").should be_nil
-        end
-      end
-
-      it "uses #hash to look up keys" do
-        x = double('0')
-        x.should_receive(:hash).and_return(0)
-        H[foo: :bar].send(method, x).should be_nil
-      end
-
-      it "uses #eql? to compare keys with the same hash code" do
-        x = double('x', hash: 42)
-        x.should_not_receive(:eql?)
-
-        y = double('y', hash: 42)
-        y.should_receive(:eql?).and_return(true)
-
-        H[y => 1][x].should == 1
-      end
-
-      it "does not use #eql? to compare keys with different hash codes" do
-        x = double('x', hash: 0)
-        x.should_not_receive(:eql?)
-
-        y = double('y', hash: 1)
-        y.should_not_receive(:eql?)
-
-        H[y => 1][x].should be_nil
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/has_key_spec.rb

@@ -1,31 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:key?, :has_key?, :include?, :member?].each do |method|
-    describe "##{method}" do
-      let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see", nil => "NIL", 2.0 => "two"] }
-
-      ["A", "B", "C", nil, 2.0].each do |key|
-        it "returns true for an existing key (#{key.inspect})" do
-          hash.send(method, key).should == true
-        end
-      end
-
-      it "returns false for a non-existing key" do
-        hash.send(method, "D").should == false
-      end
-
-      it "uses #eql? for equality" do
-        hash.send(method, 2).should == false
-      end
-
-      it "returns true if the key is found and maps to nil" do
-        H["A" => nil].send(method, "A").should == true
-      end
-
-      it "returns true if the key is found and maps to false" do
-        H["A" => false].send(method, "A").should == true
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/has_value_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  let(:hash) { H[toast: 'buttered', jam: 'strawberry'] }
-
-  [:value?, :has_value?].each do |method|
-    describe "##{method}" do
-      it "returns true if any key/val pair in Hash has the same value" do
-        hash.send(method, 'strawberry').should == true
-      end
-
-      it "returns false if no key/val pair in Hash has the same value" do
-        hash.send(method, 'marmalade').should == false
-      end
-
-      it "uses #== to check equality" do
-        H[a: EqualNotEql.new].send(method, EqualNotEql.new).should == true
-        H[a: EqlNotEqual.new].send(method, EqlNotEqual.new).should == false
-      end
-
-      it "works on a large hash" do
-        large = H.new((1..1000).zip(2..1001))
-        [2, 100, 200, 500, 900, 1000, 1001].each { |n| large.value?(n).should == true }
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/hash_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#hash" do
-    it "values are sufficiently distributed" do
-      (1..4000).each_slice(4).map { |ka, va, kb, vb| H[ka => va, kb => vb].hash }.uniq.size.should == 1000
-    end
-
-    it "differs given the same keys and different values" do
-      H["ka" => "va"].hash.should_not == H["ka" => "vb"].hash
-    end
-
-    it "differs given the same values and different keys" do
-      H["ka" => "va"].hash.should_not == H["kb" => "va"].hash
-    end
-
-    it "generates the same hash value for a hash regardless of the order things were added to it" do
-      key1 = DeterministicHash.new('abc', 1)
-      key2 = DeterministicHash.new('xyz', 1)
-      H.empty.put(key1, nil).put(key2, nil).hash.should == H.empty.put(key2, nil).put(key1, nil).hash
-    end
-
-    describe "on an empty hash" do
-      it "returns 0" do
-        H.empty.hash.should == 0
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/inspect_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#inspect" do
-    [
-      [[], 'Immutable::Hash[]'],
-      [["A" => "aye"], 'Immutable::Hash["A" => "aye"]'],
-      [[DeterministicHash.new("A", 1) => "aye", DeterministicHash.new("B", 2) => "bee", DeterministicHash.new("C", 3) => "see"], 'Immutable::Hash["A" => "aye", "B" => "bee", "C" => "see"]']
-    ].each do |values, expected|
-      describe "on #{values.inspect}" do
-        it "returns #{expected.inspect}" do
-          H[*values].inspect.should == expected
-        end
-      end
-    end
-
-    [
-      {},
-      {"A" => "aye"},
-      {a: "aye", b: "bee", c: "see"}
-    ].each do |values|
-      describe "on #{values.inspect}" do
-        it "returns a string which can be eval'd to get an equivalent object" do
-          original = H.new(values)
-          eval(original.inspect).should eql(original)
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/invert_spec.rb

@@ -1,30 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#invert" do
-    let(:hash) { H[a: 3, b: 2, c: 1] }
-
-    it "uses the existing keys as values and values as keys" do
-      hash.invert.should eql(H[3 => :a, 2 => :b, 1 => :c])
-    end
-
-    it "will select one key/value pair among multiple which have same value" do
-      [H[1 => :a],
-       H[1 => :b],
-       H[1 => :c]].include?(H[a: 1, b: 1, c: 1].invert).should == true
-    end
-
-    it "doesn't change the original Hash" do
-      hash.invert
-      hash.should eql(H[a: 3, b: 2, c: 1])
-    end
-
-    context "from a subclass of Hash" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Immutable::Hash)
-        instance = subclass.new(a: 1, b: 2)
-        instance.invert.class.should be(subclass)
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/key_spec.rb

@@ -1,27 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#key" do
-    let(:hash) { H[a: 1, b: 1, c: 2, d: 3] }
-
-    it "returns a key associated with the given value, if there is one" do
-      [:a, :b].include?(hash.key(1)).should == true
-      hash.key(2).should be(:c)
-      hash.key(3).should be(:d)
-    end
-
-    it "returns nil if there is no key associated with the given value" do
-      hash.key(5).should be_nil
-      hash.key(0).should be_nil
-    end
-
-    it "uses #== to compare values for equality" do
-      hash.key(EqualNotEql.new).should_not be_nil
-      hash.key(EqlNotEqual.new).should be_nil
-    end
-
-    it "doesn't use default block if value is not found" do
-      H.new(a: 1) { fail }.key(2).should be_nil
-    end
-  end
-end

data/spec/lib/immutable/hash/keys_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#keys" do
-    let(:hash) { H["A" => "aye", "B" => "bee", "C" => "see"] }
-
-    it "returns the keys as a set" do
-      hash.keys.should eql(S["A", "B", "C"])
-    end
-
-    it "returns frozen String keys" do
-      hash.keys.each { |s| s.should be_frozen }
-    end
-  end
-end

data/spec/lib/immutable/hash/map_spec.rb

@@ -1,45 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  [:map, :collect].each do |method|
-    describe "##{method}" do
-      context "when empty" do
-        it "returns self" do
-          H.empty.send(method) {}.should equal(H.empty)
-        end
-      end
-
-      context "when not empty" do
-        let(:hash) { H["A" => "aye", "B"  => "bee", "C" => "see"] }
-
-        context "with a block" do
-          let(:mapped) { hash.send(method) { |key, value| [key.downcase, value.upcase] }}
-
-          it "preserves the original values" do
-            mapped
-            hash.should eql(H["A" => "aye", "B"  => "bee", "C" => "see"])
-          end
-
-          it "returns a new hash with the mapped values" do
-            mapped.should eql(H["a" => "AYE", "b"  => "BEE", "c" => "SEE"])
-          end
-        end
-
-        context "with no block" do
-          it "returns an Enumerator" do
-            hash.send(method).class.should be(Enumerator)
-            hash.send(method).each { |k,v| [k.downcase, v] }.should == hash.map { |k,v| [k.downcase, v] }
-          end
-        end
-      end
-
-      context "from a subclass" do
-        it "returns an instance of the subclass" do
-          subclass = Class.new(Immutable::Hash)
-          instance = subclass.new('a' => 'aye', 'b' => 'bee')
-          instance.map { |k,v| [k, v.upcase] }.class.should be(subclass)
-        end
-      end
-    end
-  end
-end

data/spec/lib/immutable/hash/marshal_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#marshal_dump/#marshal_load" do
-    let(:ruby) do
-      File.join(RbConfig::CONFIG["bindir"], RbConfig::CONFIG["ruby_install_name"])
-    end
-    let(:child_cmd) do
-      %Q|#{ruby} -I lib -r immutable -e 'dict = Immutable::Hash[existing_key: 42, other_thing: "data"]; $stdout.write(Marshal.dump(dict))'|
-    end
-
-    let(:reloaded_hash) do
-      IO.popen(child_cmd, "r+") do |child|
-        reloaded_hash = Marshal.load(child)
-        child.close
-        reloaded_hash
-      end
-    end
-
-    it "can survive dumping and loading into a new process" do
-      expect(reloaded_hash).to eql(H[existing_key: 42, other_thing: "data"])
-    end
-
-    it "is still possible to find items by key after loading" do
-      expect(reloaded_hash[:existing_key]).to eq(42)
-    end
-  end
-end

data/spec/lib/immutable/hash/merge_spec.rb

@@ -1,82 +0,0 @@
-require "spec_helper"
-
-describe Immutable::Hash do
-  describe "#merge" do
-    [
-      [{}, {}, {}],
-      [{"A" => "aye"}, {}, {"A" => "aye"}],
-      [{"A" => "aye"}, {"A" => "bee"}, {"A" => "bee"}],
-      [{"A" => "aye"}, {"B" => "bee"}, {"A" => "aye", "B" => "bee"}],
-      [(1..300).zip(1..300), (150..450).zip(150..450), (1..450).zip(1..450)]
-    ].each do |a, b, expected|
-      context "for #{a.inspect} and #{b.inspect}" do
-        let(:hash_a) { H[a] }
-        let(:hash_b) { H[b] }
-        let(:result) { hash_a.merge(hash_b) }
-
-        it "returns #{expected.inspect} when passed an Immutable::Hash"  do
-          result.should eql(H[expected])
-        end
-
-        it "returns #{expected.inspect} when passed a Ruby Hash" do
-          H[a].merge(::Hash[b]).should eql(H[expected])
-        end
-
-        it "doesn't change the original Hashes" do
-          result
-          hash_a.should eql(H[a])
-          hash_b.should eql(H[b])
-        end
-      end
-    end
-
-    context "when merging with an empty Hash" do
-      it "returns self" do
-        hash = H[a: 1, b: 2]
-        hash.merge(H.empty).should be(hash)
-      end
-    end
-
-    context "when merging with subset Hash" do
-      it "returns self" do
-        big_hash   = H[(1..300).zip(1..300)]
-        small_hash = H[(1..200).zip(1..200)]
-        big_hash.merge(small_hash).should be(big_hash)
-      end
-    end
-
-    context "when called on a subclass" do
-      it "returns an instance of the subclass" do
-        subclass = Class.new(Immutable::Hash)
-        instance = subclass.new(a: 1, b: 2)
-        instance.merge(c: 3, d: 4).class.should be(subclass)
-      end
-    end
-
-    it "sets any duplicate key to the value of block if passed a block" do
-      h1 = H[a: 2, b: 1, d: 5]
-      h2 = H[a: -2, b: 4, c: -3]
-      r = h1.merge(h2) { |k,x,y| nil }
-      r.should eql(H[a: nil, b: nil, c: -3, d: 5])
-
-      r = h1.merge(h2) { |k,x,y| "#{k}:#{x+2*y}" }
-      r.should eql(H[a: "a:-2", b: "b:9", c: -3, d: 5])
-
-      lambda {
-        h1.merge(h2) { |k, x, y| raise(IndexError) }
-      }.should raise_error(IndexError)
-
-      r = h1.merge(h1) { |k,x,y| :x }
-      r.should eql(H[a: :x, b: :x, d: :x])
-    end
-
-    it "yields key/value pairs in the same order as #each" do
-      hash = H[a: 1, b: 2, c: 3]
-      each_pairs = []
-      merge_pairs = []
-      hash.each { |k, v| each_pairs << [k, v] }
-      hash.merge(hash) { |k, v1, v2| merge_pairs << [k, v1] }
-      each_pairs.should == merge_pairs
-    end
-  end
-end