fr 0.9.1

data/lib/fr/tzipper/path.rb

@@ -0,0 +1,125 @@
+module Fr
+  module TZipper
+
+    class AbstractPath
+
+      # @return [AbstractPath]
+      # abstract :parent
+
+      # Contains the node's leftward siblings, sorted nearest to furthest
+      #
+      # @return [Array<#leaf?, #children, #copy>]
+      # abstract :left
+
+      # Contains the node's rightward siblings, sorted nearest to furthest
+      #
+      # @return [Array<#leaf?, #children, #copy>]
+      # abstract :right
+
+      # True when the node has no rightward siblings
+      # abstract :last?
+
+      # True when the node has no leftward siblings
+      # abstract :first?
+
+      # Distance from the root node
+      #
+      # @return [Integer]
+      # abstract :depth
+    end
+
+    # @private
+    Root = Class.new(AbstractPath) do
+
+      # @return self
+      def parent
+        self
+      end
+
+      # (see AbstractPath#left)
+      def left
+        []
+      end
+
+      # (see AbstractPath#right)
+      def right
+        []
+      end
+
+      # (see AbstractPath#last?)
+      # @return true
+      def last?
+        true
+      end
+
+      # (see AbstractPath#first?)
+      # @return true
+      def first?
+        true
+      end
+
+      # (see AbstractPath#depth)
+      def depth
+        0
+      end
+
+      def position
+        nil
+      end
+
+      # @return [String]
+      def inspect
+        "root"
+      end
+    end.new
+
+    class Hole < AbstractPath
+
+      # (see AbstractPath#right)
+      attr_reader :left
+
+      # @return [AbstractPath]
+      attr_reader :parent
+
+      # (see AbstractPath#left)
+      attr_reader :right
+
+      def initialize(left, parent, right)
+        @left, @parent, @right =
+          left, parent, right
+      end
+
+      # (see AbstractPath#last?)
+      def last?
+        @right.empty?
+      end
+
+      # (see AbstractPath#first?)
+      def first?
+        @left.empty?
+      end
+
+      # (see AbstractPath#depth)
+      def depth
+        1 + @parent.depth
+      end
+
+      def position
+        @left.length
+      end
+
+      # @return [String]
+      def inspect
+        "#{@parent.inspect}/#{@left.length}"
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        AbstractCursor === other and
+        depth    == other.depth  and
+        position == other.position
+      end
+    end
+
+  end
+end

data/lib/fr/tzipper/root_cursor.rb

@@ -0,0 +1,124 @@
+module Fr
+  module TZipper
+
+    class RootCursor < AbstractCursor
+
+      # @return [AbstractNode]
+      attr_reader :node
+
+      # @return [AbstractPath]
+      attr_reader :path
+
+      def initialize(node)
+        @node, @path =
+          node, Root
+      end
+
+      # @group Query the Tree Location
+      #########################################################################
+
+      # (see AbstractCursor#depth)
+      def depth
+        0
+      end
+
+      # (see AbstractCursor#first?)
+      def first?
+        true
+      end
+
+      # (see AbstractCursor#last?)
+      def last?
+        true
+      end
+
+      # (see AbstractCursor#leaf?)
+      def leaf?
+        @node.leaf? or @node.children.empty?
+      end
+
+      # (see AbstractCursor#root?)
+      def root?
+        true
+      end
+
+      # @group Traversing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#first)
+      def first
+        self
+      end
+
+      # (see AbstractCursor#last)
+      def last
+        self
+      end
+
+      # (see AbstractCursor#next)
+      # @return [void]
+      def next
+        raise Errors::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#prev)
+      # @return [void]
+      def prev
+        raise Errors::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#root)
+      # @return [RootCursor]
+      def root
+        self
+      end
+
+      # (see AbstractCursor#up)
+      # @return [void]
+      def up
+        raise Errors::ZipperError,
+          "root node has no parent"
+      end
+
+      # @group Editing the Tree
+      #########################################################################
+
+      # (see AbstractCursor#append)
+      # @return [void]
+      def append(node)
+        raise Errors::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#prepend)
+      # @return [void]
+      def prepend(node)
+        raise Errors::ZipperError,
+          "root node has no siblings"
+      end
+
+      # (see AbstractCursor#replace)
+      # @return [RootCursor]
+      def replace(node)
+        RootCursor.new(node)
+      end
+
+      # (see AbstractCursor#delete)
+      # @return [void]
+      def delete
+        raise Errors::ZipperError,
+          "cannot delete root node"
+      end
+
+      # @endgroup
+      #########################################################################
+
+      def inspect
+        "Cursor(Root, #{@node.inspect})"
+      end
+    end
+
+  end
+end

data/lib/fr/unfold.rb

@@ -0,0 +1,93 @@
+class << Array
+  # Recursive version
+  def unfold(seed, &block)
+    m = yield(seed)
+    m.fold([]){|(item, seed)| [item] + unfold(seed, &block) }
+  end
+
+  # First generated element is first in Array
+  def unfold(seed)
+    [].tap do |xs|
+      while true
+        yield(seed).fold(false) do |(item,seed_)|
+          xs << item
+          seed = seed_
+        end || break
+      end
+    end
+  end
+
+  # First generated element is last in Array
+  def unfoldR(seed, &block)
+    m = yield(seed)
+    m.fold([]){|(item, seed)| unfold(seed, &block) + [item] }
+  end
+
+  # First generated element is last in Array
+  def unfoldR(seed)
+    [].tap do |xs|
+      while true
+        yield(seed).fold(false) do |(item,seed_)|
+          xs.unshift(item)
+          seed = seed_
+        end || break
+      end
+    end
+  end
+end
+
+class << Hash
+  # Recursive version
+  def unfold(seed, &block)
+    m = yield(seed)
+    m.fold({}){|(item, seed)| unfold(seed, &block).merge(item) }
+  end
+
+  # Iterative version
+  def unfold(seed)
+    {}.tap do |xs|
+      while true
+        yield(seed).fold(false) do |(item,seed_)|
+          xs.update(item)
+          seed = seed_
+        end || break
+      end
+    end
+  end
+end
+
+class Set; end
+class << Set
+  # Recursive version
+  def unfold(seed, &block)
+    m = yield(seed)
+    m.fold(Set.new){|(item, seed)| unfold(seed, &block) << item }
+  end
+
+  # Iterative version
+  def unfold(seed)
+    Set.new.tap do |xs|
+      while true
+        yield(seed).fold(false) do |(item,seed_)|
+          xs  << item
+          seed = seed_
+        end || break
+      end
+    end
+  end
+end
+
+class << Enumerator
+  # First generated element is first in Enumerator
+  def unfold(seed)
+    Enumerator.new do |yielder|
+      while true
+        yield(seed).fold(false) do |(item,seed_)|
+          yielder.yield item
+          seed = seed_
+          true
+        end || break
+      end
+    end
+  end
+end

data/spec/examples/szipper.example

@@ -0,0 +1,652 @@
+require "spec_helper"
+
+describe Fr::SZipper do
+
+  let(:z) { Fr::SZipper       }
+  let(:n) { Fr::SZipper::Node }
+
+  describe ".build(enum)" do
+    context "empty" do
+      subject { z.build }
+
+      it { should be_head }
+      it { should be_tail }
+      it { should be_empty }
+      it { should_not respond_to(:node) }
+    end
+
+    context "non-empty" do
+      subject { z.build(n.new("x")) }
+
+      it { should be_head }
+      it { should_not be_empty }
+      it { should respond_to(:node) }
+    end
+  end
+
+  describe "#head?" do
+    subject { z.build(n.build(%w(x y z))) }
+
+    # The first element (or empty zipper)
+    specify { subject.should be_head }
+    specify { z.build.should be_head }
+    specify { z.build.prev(true).should be_head }
+    specify { z.build.next(true).should be_head }
+
+    # Other elements
+    specify { subject.prev(true).should_not be_head }
+    specify { subject.next.should_not be_head }
+    specify { subject.next.next.should_not be_head }
+    specify { subject.next.next.next(true).should_not be_head }
+  end
+
+  describe "#head" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    # Empty sequence has no head element
+    specify { expect { n.build.head }.to raise_error }
+    specify { expect { n.build.prev(true).head }.to raise_error }
+    specify { expect { n.build.next(true).head }.to raise_error }
+
+    # The first element
+    specify { subject.head.should eql(subject) }
+    specify { subject.head.node.should eql(x) }
+
+    # Other elements
+    specify { subject.prev(true).head.node.should eql(x) }
+    specify { subject.next.head.node.should eql(x) }
+    specify { subject.next.next.head.node.should eql(x) }
+    specify { subject.next.next.next(true).head.node.should eql(x) }
+  end
+
+  describe "#tail?" do
+    subject { z.build(n.build(%w(x y z))) }
+
+    # The last element
+    specify { subject.next.next.should be_tail }
+    specify { z.build.should be_tail }
+    specify { z.build.prev(true).should be_tail }
+    specify { z.build.next(true).should be_tail }
+
+    # Other elements
+    specify { subject.should_not be_tail }
+    specify { subject.prev(true).should_not be_tail }
+    specify { subject.next.should_not be_tail }
+    specify { subject.next.next.next(true).should_not be_tail }
+  end
+
+  describe "#tail" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    # Empty sequence has no tail element
+    specify { expect { z.build.tail }.to raise_error }
+
+    # Tail element
+    specify { subject.tail.should be_tail }
+    specify { subject.next.next.tail.node.should eql(x.next.next) }
+    specify { subject.next.next.tail.should eql(subject.next.next) }
+
+    # Other elements
+    specify { subject.tail.node.should eql(x.next.next) }
+    specify { subject.prev(true).tail.node.should eql(x.next.next) }
+    specify { subject.next.tail.node.should eql(x.next.next) }
+    specify { subject.next.next.next(true).tail.node.should eql(x.next.next) }
+  end
+
+  describe "#position" do
+    subject { z.build(n.build(%w(x y z))) }
+
+    # Empty sequence
+    specify { z.build.position.should == -1 }
+
+    # Non-empty sequence
+    specify { subject.prev(true).position.should == -1 }
+    specify { subject.position.should == 0 }
+    specify { subject.next.position.should == 1 }
+    specify { subject.next.next.position.should == 2 }
+    specify { subject.next.next.next(true).position.should == 3 }
+  end
+
+  describe "#empty?" do
+    subject { z.build(n.build(%w(x y z))) }
+
+    # True if no current or following elements
+    specify { z.build.should be_empty }
+    specify { subject.tail.next(true).should be_empty }
+
+    # False when on an element or elements follow
+    specify { subject.should_not be_empty }
+    specify { subject.next.should_not be_empty }
+    specify { subject.next.next.should_not be_empty }
+    specify { subject.prev(true).should_not be_empty }
+  end
+
+  describe "#prev" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    # head.prev is ill-defined
+    specify { expect { z.build.prev }.to raise_error }
+    specify { expect { subject.prev }.to raise_error }
+
+    # Empty sequence has no previous element
+    specify { z.build.prev(true).should == z.build }
+
+    # Non-empty sequence
+    specify { subject.prev(true).should_not respond_to(:node) }
+    specify { subject.tail.prev.node.should eql(x.next) }
+    specify { subject.tail.prev.prev.node.should eql(x) }
+  end
+
+  describe "#next" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    # tail.next is ill-defined
+    specify { expect { z.build.next }.to raise_error }
+    specify { expect { subject.tail.next }.to raise_error }
+
+    # Empty sequence has no next element
+    specify { z.build.next(true).should == z.build }
+
+    # Non-empty sequence
+    specify { subject.next.node.should eql(x.next) }
+    specify { subject.prev(true).next.node.should eql(x) }
+    specify { subject.next.next.node.should eql(x.next.next) }
+    specify { subject.next.next.next(true).should_not respond_to(:node) }
+    specify { subject.tail.next(true).next(true).should_not respond_to(:node) }
+  end
+
+  describe "#append(node)" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # Positioned at newly inserted node
+      specify { z.build.append(n.new("_")).node.value.should == "_" }
+      specify { z.build.append(n.new("_")).should be_head }
+      specify { z.build.append(n.new("_")).should be_tail }
+    end
+
+    context "at head" do
+      # Positioned at newly inserted node
+      specify { subject.append(n.new("_")).should_not be_head }
+      specify { subject.append(n.new("_")).node.value.should == "_" }
+      specify { subject.append(n.new("_")).prev.node.value.should == "x" }
+      specify { subject.append(n.new("_")).next.node.value.should == "y" }
+
+      # Previous node's `next` is updated
+      specify { subject.append(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.append(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "at head.next" do
+      # Positioned at newly inserted node
+      specify { subject.next.append(n.new("_")).node.value.should == "_" }
+      specify { subject.next.append(n.new("_")).prev.node.value.should == "y" }
+      specify { subject.next.append(n.new("_")).next.node.value.should == "z" }
+
+      # Previous node's `next` is updated
+      specify { subject.next.append(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.next.append(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "at tail" do
+      # Positioned at newly inserted node
+      specify { subject.tail.append(n.new("_")).node.value.should == "_" }
+      specify { subject.tail.append(n.new("_")).prev.node.value.should == "z" }
+      specify { subject.tail.append(n.new("_")).should be_tail }
+
+      # Previous node's `next` is updated
+      specify { subject.tail.append(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.tail.append(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "at head.prev" do
+      # Positioned at newly inserted node
+      specify { subject.prev(true).append(n.new("_")).should be_head }
+      specify { subject.prev(true).append(n.new("_")).node.value.should == "_" }
+      specify { subject.prev(true).append(n.new("_")).next.node.value.should == "x" }
+      specify { subject.prev(true).append(n.new("_")).prev(true).position.should == -1 }
+    end
+
+    context "at tail.next" do
+      # Positioned at newly inserted node
+      specify { subject.tail.next(true).append(n.new("_")).should be_tail }
+      specify { subject.tail.next(true).append(n.new("_")).node.value.should == "_" }
+      specify { subject.tail.next(true).append(n.new("_")).prev.node.value.should == "z" }
+
+      # Previous node's `next` is updated
+      specify { subject.tail.next(true).append(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.tail.next(true).append(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "append(y).prev.append(x)" do
+      # todo
+      # <x> <y> x y z
+      # a <x> <y> b c
+      # a b <x> <y> c
+      # x y z <x> <y>
+    end
+  end
+
+  describe "#prepend(node)" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # Positioned at newly inserted node
+      specify { z.build.prepend(n.new("_")).node.value.should == "_" }
+      specify { z.build.prepend(n.new("_")).should be_head }
+      specify { z.build.prepend(n.new("_")).should be_tail }
+    end
+
+    context "at head" do
+      # Positioned at newly inserted node
+      specify { subject.prepend(n.new("_")).should be_head }
+      specify { subject.prepend(n.new("_")).node.value.should == "_" }
+      specify { subject.prepend(n.new("_")).next.node.value.should == "x" }
+    end
+
+    context "at head.next" do
+      # Positioned at newly inserted node
+      specify { subject.next.prepend(n.new("_")).node.value.should == "_" }
+      specify { subject.next.prepend(n.new("_")).prev.node.value.should == "x" }
+      specify { subject.next.prepend(n.new("_")).next.node.value.should == "y" }
+
+      # Previous node's `next` is updated
+      specify { subject.next.prepend(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.next.prepend(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "at tail" do
+      # Positioned at newly inserted node
+      specify { subject.tail.prepend(n.new("_")).should_not be_tail }
+      specify { subject.tail.prepend(n.new("_")).node.value.should == "_" }
+      specify { subject.tail.prepend(n.new("_")).prev.node.value.should == "y" }
+      specify { subject.tail.prepend(n.new("_")).next.node.value.should == "z" }
+
+      # Previous node's `next` is updated
+      specify { subject.tail.prepend(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.tail.prepend(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "at head.prev" do
+      # Positioned at newly inserted node
+      specify { subject.prev(true).prepend(n.new("_")).should be_head }
+      specify { subject.prev(true).prepend(n.new("_")).node.value.should == "_" }
+      specify { subject.prev(true).prepend(n.new("_")).next.node.value.should == "x" }
+      specify { subject.prev(true).prepend(n.new("_")).prev(true).position.should == -1 }
+    end
+
+    context "at tail.next" do
+      # Positioned at newly inserted node
+      specify { subject.tail.next(true).prepend(n.new("_")).should be_tail }
+      specify { subject.tail.next(true).prepend(n.new("_")).node.value.should == "_" }
+      specify { subject.tail.next(true).prepend(n.new("_")).prev.node.value.should == "z" }
+
+      # Previous node's `next` is updated
+      specify { subject.tail.next(true).prepend(n.new("_")).prev.next.node.value.should == "_" }
+      specify { subject.tail.next(true).prepend(n.new("_")).prev.node.next.value.should == "_" }
+    end
+
+    context "prepend(y).prev.prepend(x)" do
+      # todo
+      # <x> <y> x y z
+      # <x> a <y> b c
+      # a <x> b <y> c
+      # x y z <x> <y>
+    end
+  end
+
+  describe "#update(node)" do
+    let(:x) { n.build(%w(x y z)) }
+    let(:m) { n.build(%w(m n o)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # Positioned at newly updated (inserted) node
+      specify { z.build.update(m).position.should == 0 }
+      specify { z.build.update(m).node.value.should == "m" }
+
+      # Doesn't copy m's entire chain
+      specify { z.build.update(m).should be_head }
+      specify { z.build.update(m).should be_tail }
+    end
+
+    context "at head" do
+      # Positioned at newly updated node
+      specify { subject.update(m).node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.update(m).position.should == subject.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.update(m).node.next.value.should == "y" }
+      specify { subject.update(m).next.node.value.should == "y" }
+
+      # todo: Explain
+      specify { subject.update(m).node.next.should eql(x.next) }
+      specify { subject.update(m).next.node.should eql(x.next) }
+    end
+
+    context "at head.next" do
+      # Positioned at newly updated node
+      specify { subject.next.update(m).node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.next.update(m).position.should == subject.next.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.next.update(m).node.next.value.should == "z" }
+      specify { subject.next.update(m).next.node.value.should == "z" }
+
+      # todo: Explain
+      specify { subject.next.update(m).node.next.should eql(x.next.next) }
+      specify { subject.next.update(m).next.node.should eql(x.next.next) }
+    end
+
+    context "at tail" do
+      # Positioned at newly updated node
+      specify { subject.tail.update(m).node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.tail.update(m).position.should == subject.tail.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.tail.update(m).should be_tail }
+
+      # todo: Explain
+      specify { subject.tail.update(m).node.next.should be_nil }
+    end
+
+    context "at head.prev" do
+      # Positioned at newly updated node
+      specify { z.build.prev(true).update(m).node.value.should == "m" }
+
+      # Creates a new head
+      specify { subject.prev(true).update(m).should be_head }
+      specify { subject.prev(true).update(m).position.should == subject.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.prev(true).update(m).node.next.value.should == "x" }
+      specify { subject.prev(true).update(m).next.node.value.should == "x" }
+
+      # todo: Explain
+      specify { subject.prev(true).update(m).node.next.should eql(x) }
+      specify { subject.prev(true).update(m).next.node.should eql(x) }
+    end
+
+    context "at tail.next" do
+      # Positioned at newly updated (inserted) node
+      specify { subject.tail.next(true).update(m).node.value.should == "m" }
+
+      # Creates a new tail
+      specify { subject.tail.next(true).update(m).should be_tail }
+      specify { subject.tail.next(true).update(m).position.should == subject.tail.position + 1 }
+
+      # Doesn't copy m's entire chain
+      specify { subject.tail.next(true).update(m).node.next.should be_nil }
+    end
+  end
+
+  describe "#update{|node| ... }" do
+    let(:x) { n.build(%w(x y z)) }
+    let(:m) { n.build(%w(m n o)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # Positioned at newly updated (inserted) node
+      specify { z.build.update{|_| m }.position.should == 0 }
+      specify { z.build.update{|_| m }.node.value.should == "m" }
+
+      # Doesn't copy m's entire chain
+      specify { z.build.update{|_| m }.should be_head }
+      specify { z.build.update{|_| m }.should be_tail }
+
+      # Yields nil
+      specify { z.build.update{|_| _.should be_nil; m }}
+    end
+
+    context "at head" do
+      # Positioned at newly updated node
+      specify { subject.update{|x| m }.node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.update{|x| m }.position.should == subject.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.update{|x| m }.node.next.value.should == "y" }
+      specify { subject.update{|x| m }.next.node.value.should == "y" }
+
+      # todo: Explain
+      specify { subject.update{|x| m }.node.next.should eql(x.next) }
+      specify { subject.update{|x| m }.next.node.should eql(x.next) }
+
+      # Yields current node
+      specify { subject.update{|o| o.should eql(x); o }}
+    end
+
+    context "at head.next" do
+      # Positioned at newly updated node
+      specify { subject.next.update{|y| m }.node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.next.update{|y| m }.position.should == subject.next.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.next.update{|y| m }.node.next.value.should == "z" }
+      specify { subject.next.update{|y| m }.next.node.value.should == "z" }
+
+      # todo: Explain
+      specify { subject.next.update{|y| m }.node.next.should eql(x.next.next) }
+      specify { subject.next.update{|y| m }.next.node.should eql(x.next.next) }
+
+      # Yields current node
+      specify { subject.next.update{|o| o.should eql(x.next); o }}
+    end
+
+    context "at tail" do
+      # Positioned at newly updated node
+      specify { subject.tail.update{|z| m }.node.value.should == "m" }
+
+      # Replaces existing node
+      specify { subject.tail.update{|z| m }.position.should == subject.tail.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.tail.update{|z| m }.should be_tail }
+
+      # todo: Explain
+      specify { subject.tail.update{|z| m }.node.next.should be_nil }
+
+      # Yields current node
+      specify { subject.tail.update{|o| o.should eql(x.next.next); o }}
+    end
+
+    context "at head.prev" do
+      # Positioned at newly updated node
+      specify { z.build.prev(true).update{|_| m }.node.value.should == "m" }
+
+      # Creates a new head
+      specify { subject.prev(true).update{|_| m }.should be_head }
+      specify { subject.prev(true).update{|_| m }.position.should == subject.position }
+
+      # Doesn't copy m's entire chain
+      specify { subject.prev(true).update{|_| m }.node.next.value.should == "x" }
+      specify { subject.prev(true).update{|_| m }.next.node.value.should == "x" }
+
+      # todo: Explain
+      specify { subject.prev(true).update{|_| m }.node.next.should eql(x) }
+      specify { subject.prev(true).update{|_| m }.next.node.should eql(x) }
+
+      # Yields nil
+      specify { subject.prev(true).update{|o| o.should be_nil; m }}
+    end
+
+    context "at tail.next" do
+      # Positioned at newly updated (inserted) node
+      specify { subject.tail.next(true).update{|_| m }.node.value.should == "m" }
+
+      # Creates a new tail
+      specify { subject.tail.next(true).update{|_| m }.should be_tail }
+      specify { subject.tail.next(true).update{|_| m }.position.should == subject.tail.position + 1 }
+
+      # Doesn't copy m's entire chain
+      specify { subject.tail.next(true).update{|_| m }.node.next.should be_nil }
+
+      # Yields nil
+      specify { subject.tail.next(true).update{|o| o.should be_nil; m }}
+    end
+  end
+
+  describe "#replace(node)" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # todo
+    end
+
+    context "at head" do
+      # todo
+    end
+
+    context "at head.next" do
+      # todo
+    end
+
+    context "at tail" do
+      # todo
+    end
+
+    context "at head.prev" do
+      # todo
+    end
+
+    context "at tail.next" do
+      # todo
+    end
+  end
+
+  describe "#delete" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # todo
+    end
+
+    context "at head" do
+      # todo
+    end
+
+    context "at head.next" do
+      # todo
+    end
+
+    context "at tail" do
+      # todo
+    end
+
+    context "at head.prev" do
+      # todo
+    end
+
+    context "at tail.next" do
+      # todo
+    end
+  end
+
+  describe "#truncate" do
+    let(:x) { n.build(%w(x y z)) }
+    subject { z.build(x) }
+
+    context "on empty stream" do
+      # todo
+    end
+
+    context "at head" do
+      # todo
+    end
+
+    context "at head.next" do
+      # todo
+    end
+
+    context "at tail" do
+      # todo
+    end
+
+    context "at head.prev" do
+      # todo
+    end
+
+    context "at tail.next" do
+      # todo
+    end
+  end
+
+end
+
+describe Fr::SZipper::Enumerable do
+
+  describe "#each{|cursor| ... }" do
+  end
+
+  describe "#all?{|node| predicate }" do
+  end
+
+  describe "#any?{|node| predicate }" do
+  end
+
+  describe "#none?{|node| predicate }" do
+  end
+
+  describe "#count{|node| predicate }" do
+  end
+
+  describe "#find{|node| predicate }" do
+  end
+
+  describe "#drop(n)" do
+  end
+
+  describe "#entries" do
+  end
+
+  describe "#map{|node| ... }" do
+  end
+
+  describe "#filter{|node| predicate }" do
+  end
+
+  describe "#reject{|node| predicate }" do
+  end
+
+  describe "#index{|node| predicate }" do
+  end
+
+  describe "#grep(pattern)" do
+  end
+
+  describe "#include?(node)" do
+  end
+
+  describe "#foldl(seed){|seed, cursor| ... }" do
+  end
+
+  describe "#reduce{|acursor, bcursor| ... }" do
+  end
+
+  describe "#max_by" do
+  end
+
+  describe "#min_by" do
+  end
+
+  describe "#minmax_by" do
+  end
+
+end