fr 0.9.1

data/lib/fr/szipper/edited_cursor.rb

@@ -0,0 +1,62 @@
+module Fr
+  module SZipper
+
+    class EditedCursor < AbstractCursor
+      attr_reader :node
+
+      def initialize(node, prev)
+        @node, @prev =
+          node, prev
+      end
+
+      def head?
+        false
+      end
+
+      def tail?
+        @node.tail?
+      end
+
+      def prev(phantom = false)
+        if @prev.head?
+          HeadCursor.new(@prev.node.copy(next: @node))
+        else
+          EditedCursor.new(@prev.node.copy(next: @node), @prev.prev)
+        end
+      end
+
+      def append(node)
+        EditedCursor.new(node.copy(next: @node.next), self)
+      end
+
+      def prepend(node)
+        EditedCursor.new(node.copy(next: @node), prev)
+      end
+
+      def update(node = nil)
+        if node.nil?
+          EditedCursor.new(yield(@node).copy(next: @node.next), @prev)
+        else
+          EditedCursor.new(node.copy(next: @node.next), @prev)
+        end
+      end
+
+      def replace(node)
+        EditCursor.new(node, @prev)
+      end
+
+      def delete
+        if @prev.head?
+          HeadCursor.new(prev.node.copy(next: @node.next))
+        else
+          EditedCursor.new(prev.node.copy(next: @node.next), @prev.prev)
+        end
+      end
+
+      def inspect
+        "Cursor([..., #{@node.inspect}, ...])"
+      end
+    end
+
+  end
+end

data/lib/fr/szipper/enumerable.rb

@@ -0,0 +1,266 @@
+module Fr
+  module SZipper
+
+    module Enumerable
+
+      def each
+        cursor = self
+        yield(cursor)
+
+        until cursor.tail?
+          cursor = cursor.next
+          yield(cursor)
+        end
+
+        self
+      end
+
+      def all?
+        catch(:done) do
+          each{|c| throw(:done, false) if !yield(c.node) }; true
+        end
+      end
+
+      def any?
+        catch(:done) do
+          each{|c| throw(:done, true) if yield(c.node) }; false
+        end
+      end
+
+      def chunk
+        # todo: defined?
+      end
+
+      def collect
+        unless tail?
+          current = yield(node)
+          next_   = Fr.thunk { self.next.collect{|n| yield(n) }.node }
+          replace(current.copy(next: next_))
+        else
+          update(yield(node))
+        end
+      end
+
+      def collect_concat
+        # todo: defined?
+      end
+
+      def count
+        foldl(0){|count, c| yield(c.node) ? count + 1 : count }
+      end
+
+      def cycle
+        # todo: defined?
+      end
+
+      def detect(default = nil)
+        catch(:done) do
+          each{|c| throw(:done, c) if yield(c.node) }; default
+        end
+      end
+
+      def drop(n)
+        # Seek n nodes forward
+        nth = n.times.inject(self.next(true)){|c,_| c.next(true) }
+        mth = node.copy(next: nth.prev.node.next)
+        replace(mth)
+      end
+
+      def drop_while
+        # todo
+      end
+
+      def entries
+        foldl([]){|entries, c| entries << c.node }
+      end
+
+      alias_method :find, :detect
+
+      def filter
+        node = filter_{|n| yield(n) }
+        unless node.nil?
+          replace(node)
+        else
+          prev(true).truncate
+        end
+      end
+
+      # @private
+      def filter_
+        unless tail?
+          Fr.thunk do
+            if yield(node)
+              node.copy(next: self.next.filter_{|n| yield(n) })
+            else
+              self.next.filter_{|n| yield(n) }
+            end
+          end
+        else
+          yield(node) ?
+            node : nil
+        end
+      end
+
+      alias_method :find_all, :filter
+
+      def index(default = nil)
+        position_ = position
+
+        catch(:done) do
+          each do |c|
+            if yield(c.node)
+              throw(:done, position_)
+            else
+              position_ += 1
+            end
+          end
+
+          default
+        end
+      end
+
+      alias_method :find_index, :index
+
+      # alias_method :first, :head
+      def first(n = 1)
+        if n == 1
+          head
+        else
+          # todo: defined?
+        end
+      end
+
+      def flat_map
+        # todo
+      end
+
+      def grep(pattern)
+        filter{|node| pattern === node }
+      end
+
+      def group_by
+        # todo: defined?
+      end
+
+      def include?(needle)
+        any?{|node| node == needle }
+      end
+
+      def foldl(svalue)
+        cursor = self
+        svalue = yield(svalue, cursor)
+        until cursor.tail?
+          cursor = cursor.next
+          svalue = yield(svalue, cursor)
+        end
+        svalue
+      end
+
+      alias_method :inject, :foldl
+
+      alias_method :map, :collect
+
+      def max
+        reduce{|a,b| a.node < b.node ? b : a }
+      end
+
+      def max_by
+        reduce{|a,b| yield(a.node) < yield(b.node) ? b : a }
+      end
+
+      def min
+        reduce{|a,b| a.node > b.node ? b : a }
+      end
+
+      def min_by
+        reduce{|a,b| yield(a.node) > yield(b.node) ? b : a }
+      end
+
+      def minmax
+        foldl([self, self]) do |(min,max), c|
+          [min.node > c.node ? c : min,
+           max.node < c.node ? c : max]
+        end
+      end
+
+      def minmax_by
+        foldl([self, self]) do |(min,max), c|
+          [yield(min.node) > yield(c.node) ? c : min,
+           yield(max.node) < yield(c.node) ? c : max]
+        end
+      end
+
+      def none?
+        catch(:done) do
+          each{|c| throw(:done, false) if yield(c.node) }; true
+        end
+      end
+
+      alias_method :one?, :any?
+
+      def partition
+        # todo
+      end
+
+      def reduce(op = nil)
+        # [].reduce(op)       #=> nil
+        # [a].reduce(op)      #=> a
+        # [a,b].reduce(op)    #=> a op b
+        # [a,b,c].reduce(op)  #=> a op b op c
+
+        svalue = self
+        cursor = self
+
+        unless op.nil?
+          until cursor.tail?
+            cursor = cursor.next
+            svalue = svalue.send(op, cursor)
+          end
+        else
+          until cursor.tail?
+            cursor = cursor.next
+            svalue = yield(svalue, cursor)
+          end
+        end
+
+        svalue
+      end
+
+      # todo:
+      # - api: this always returns a cursor pointed at tail (ugh)
+      # - api: should be lazy
+      # - bug: doesn't filter tail element
+      def reject
+        cursor = self
+        until cursor.tail?
+          cursor = yield(cursor.node) ?
+            cursor.replace(cursor.node.next) :
+            cursor.next
+        end
+        cursor
+      end
+
+      alias_method :select, :filter
+
+      def sort
+        # todo: defined?
+      end
+
+      def take(n)
+        # todo: defined?
+      end
+
+      def take_while
+        # todo: defined?
+      end
+
+      alias_method :to_a, :entries
+
+      def zip(stream, *streams)
+        # todo: should be lazy
+      end
+
+    end
+
+  end
+end

data/lib/fr/szipper/head_cursor.rb

@@ -0,0 +1,71 @@
+module Fr
+  module SZipper
+
+    class HeadCursor < AbstractCursor
+      # @return [#next, #tail?]
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def position
+        0
+      end
+
+      def head?
+        true
+      end
+
+      def tail?
+        @node.tail?
+      end
+
+      def head
+        self
+      end
+
+      def prev(phantom = false)
+        if phantom
+          HeadPrevCursor.new(@node)
+        else
+          raise Errors::ZipperError,
+            "head node has no prev"
+        end
+      end
+
+      def append(node)
+        EditedCursor.new(node.copy(next: @node.next), self)
+      end
+
+      def prepend(node)
+        HeadCursor.new(node.copy(next: @node))
+      end
+
+      def update(node = nil)
+        if node.nil?
+          HeadCursor.new(yield(@node).copy(next: @node.next))
+        else
+          HeadCursor.new(node.copy(next: @node.next))
+        end
+      end
+
+      def replace(node)
+        HeadCursor.new(node)
+      end
+
+      def delete
+        if tail?
+          HeadPrevCursor.new(nil)
+        else
+          HeadCursor.new(@node.next)
+        end
+      end
+
+      def inspect
+        "Cursor([#{@node.inspect}, ...])"
+      end
+    end
+
+  end
+end

data/lib/fr/szipper/head_prev_cursor.rb

@@ -0,0 +1,112 @@
+module Fr
+  module SZipper
+
+    class HeadPrevCursor < AbstractCursor
+      def initialize(node)
+        @node = node
+      end
+
+      def position
+        -1
+      end
+
+      def head?
+        @node.nil?
+      end
+
+      def tail?
+        @node.nil?
+      end
+
+      def empty?
+        @node.nil?
+      end
+
+      def head
+        if @node.nil?
+          raise Errors::ZipperError,
+            "head.prev has no head"
+        else
+          HeadCursor.new(@node)
+        end
+      end
+
+      def tail
+        if @node.nil?
+          raise Errors::ZipperError,
+            "head.prev has no tail"
+        else
+          HeadCursor.new(@node).tail
+        end
+      end
+
+      def prev(phantom = false)
+        if phantom
+          self
+        else
+          raise Errors::ZipperError,
+            "head.prev has no prev"
+        end
+      end
+
+      def next(phantom = false)
+        if tail?
+          if phantom
+            self
+          else
+            raise Errors::ZipperError,
+              "head.prev has no next"
+          end
+        else
+          HeadCursor.new(@node)
+        end
+      end
+
+      def append(node)
+        HeadCursor.new(node.copy(next: @node))
+      end
+
+      def prepend(node)
+        HeadCursor.new(node.copy(next: @node))
+      end
+
+      def update(node = nil)
+        if node.nil?
+          HeadCursor.new(yield(nil).copy(next: @node))
+        else
+          HeadCursor.new(node.copy(next: @node))
+        end
+      end
+
+      def replace(node)
+        HeadCursor.new(node)
+      end
+
+      def delete
+        if tail?
+          self
+        else
+          HeadCursor.new(@node)
+        end
+      end
+
+      def truncate
+        HeadPrevCursor.new(nil)
+      end
+
+      def inspect
+        if tail?
+          "Cursor([___])"
+        else
+          "Cursor([___, #{@node.inspect}, ...])"
+        end
+      end
+
+      def ==(other)
+        HeadPrevCursor === other and
+        not empty? ^ other.empty?
+      end
+    end
+
+  end
+end