fr 0.9.1

data/spec/examples/unfold.example

@@ -0,0 +1,90 @@
+require "spec_helper"
+
+describe Enumerator, "#unfold" do
+  it "halts on Fr.none" do
+    Enumerator.unfold(:seed){|n| Fr.none }.entries.should be_empty
+  end
+
+  it "generates collection lazily" do
+    # This wouldn't terminate otherwise
+    tens = Enumerator.unfold(10){|n| Fr.some([n, n]) }
+    tens.take(10).should == [10]*10
+  end
+
+  it "preserves order" do
+    xs = Enumerator.unfold(10){|n| (n > 0).maybe([n, n-1]) }
+    xs.entries.should == [10,9,8,7,6,5,4,3,2,1]
+  end
+
+  example "digits" do
+    radix  = rand(64-1) + 2
+    number = rand(100000000)
+
+    digits =  Enumerator.unfold(number){|n| (n > 0).maybe([n%radix, n/radix]) }
+    num, _ =  digits.inject([0, 0]){|(n,k),d| [n+d*radix**k, k+1] }
+
+    num.should == number
+  end
+end
+
+describe Array, "#unfold" do
+  specify { Array.unfold(:seed){|n| Fr.none }.should be_empty }
+
+  it "preserves order" do
+    xs = Array.unfold(10){|n| (n > 0).maybe([n, n-1]) }
+    xs.entries.should == [10,9,8,7,6,5,4,3,2,1]
+  end
+
+  example "digits" do
+    radix  = rand(64-1) + 2
+    number = rand(100000000)
+
+    digits =  Array.unfold(number){|n| (n > 0).maybe([n%radix, n/radix]) }
+    num, _ =  digits.inject([0, 0]){|(n,k),d| [n+d*radix**k, k+1] }
+
+    num.should == number
+  end
+
+  example "walk to total" do
+    # If I take steps of random sizes, between -10 and +10 units, how
+    # many steps do I need to take to accumulate +50 total units?
+    steps  = Array.unfold(0) do |total|
+      step = rand(21)-10
+      (total < 50).maybe([step, total + step])
+    end
+
+    steps.min.should >= -10
+    steps.max.should <= +10
+
+    steps.reduce(:+).should >= 50
+    steps.reduce(:+).should <= 60
+  end
+end
+
+describe Array, "#unfoldR" do
+  specify { Array.unfoldR(:seed){|n| Fr.none }.should be_empty }
+
+  it "preserves order" do
+    xs = Array.unfoldR(10){|n| (n > 0).maybe([n, n-1]) }
+    xs.entries.should == [1,2,3,4,5,6,7,8,9,10]
+  end
+
+  example "digits" do
+    radix  = rand(64-1) + 2
+    number = rand(100000000)
+    radlog = Integer(Math.log(number)/Math.log(radix))
+
+    digits =  Array.unfoldR(number){|n| (n > 0).maybe([n%radix, n/radix]) }
+    num, n =  digits.inject([0, radlog]){|(n,k),d| [n+d*radix**k, k-1] }
+
+    num.should == number
+  end
+end
+
+describe Hash, "#unfold" do
+  specify { Hash.unfold(:seed){|n| Fr.none }.should be_empty }
+end
+
+describe Set, "#unfold" do
+  specify { Set.unfold(:seed){|n| Fr.none }.should be_empty }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require "rspec"
+require "fr"
+
+require "simplecov"
+SimpleCov.start
+
+# Require supporting files with custom matchers and macros
+Pathname.new(File.dirname(__FILE__)).tap do |specdir|
+  Dir["#{specdir}/support/**/*.rb"].each do |file|
+    require Pathname.new(file).relative_path_from(specdir)
+  end
+end
+
+RSpec.configure do |config|
+  # rspec -I lib -t random spec
+  # config.filter_run :random => true
+
+  # rspec -I lib -t ~random spec
+  # config.filter_run_excluding :random => true
+  # config.filter_run(:focus  => true)
+
+  # srand 44182052595481443184625304627718313206
+end

data/spec/support/szipper/model.rb

@@ -0,0 +1,225 @@
+module Fr
+  module SZipper
+
+    class Model
+      attr_reader :position
+
+      def self.build(node = nil)
+        if node.nil?
+          Model.new(-1, [])
+        else
+          Model.new(0, Array.unfold(node){|seed| (!seed.nil?).maybe([seed, seed.next]) })
+        end
+      end
+
+      def initialize(position, elements)
+        @position, @elements =
+          position, elements.map.with_index{|node, k| node.copy(next: elements[k+1]) }
+      end
+
+      def copy(changes = {})
+        Model.new \
+          changes.fetch(:position, @position),
+          changes.fetch(:elements, @elements)
+      end
+
+      def node
+        if @position >= 0 and @position < @elements.length
+          @elements[@position]
+        else
+          raise Errors::ZipperError,
+            "no node at this position"
+        end
+      end
+
+      #   .      .
+      # a b c -> a b c
+      def prev(phantom = false)
+        if @position.zero?
+          if phantom
+            copy(position: -1)
+          else
+            raise Errors::ZipperError,
+              "no prev element"
+          end
+        else
+          copy(position: @position - 1)
+        end
+      end
+
+      # .          .
+      # a b c -> a b c
+      def next(phantom = false)
+        if @position >= @elements.size - 1
+          if phantom
+            copy(position: @elements.size)
+          else
+            raise Errors::ZipperError,
+              "no next element"
+          end
+        else
+          copy(position: @position + 1)
+        end
+      end
+
+      def head?
+        @elements.empty? or @position.zero?
+      end
+
+      def tail?
+        @elements.empty? or @position == @elements.size - 1
+      end
+
+      def empty?
+        @elements.empty? or @position >= @elements.size
+      end
+
+      # .
+      # a b c
+      def head
+        if @elements.empty?
+          self
+        else
+          copy(position: 0)
+        end
+      end
+
+      #     .
+      # a b c
+      def tail
+        if @elements.empty?
+          self
+        else
+          copy(position: @elements.size - 1)
+        end
+      end
+
+      #   .        .
+      # a b c -> a b X Y Z c
+      def append(node)
+        enum = unfold(node)
+
+        if @elements.empty?
+          copy(position: -1,
+               elements: enum)
+        elsif @position >= @elements.size - 1
+          # tail.next
+          copy(position: @elements.size,
+               elements: @elements.dup.concat(enum))
+        elsif @position < 0
+          copy(position: 0,
+               elements: @elements.dup.unshift(*enum))
+        else
+          copy(position: @position,
+               elements: @elements.dup.insert(@position + 1, *enum))
+        end
+      end
+
+      #   .              .
+      # a b c -> a X Y Z b c
+      def prepend(node)
+        enum = unfold(node)
+
+        if @elements.empty?
+          copy(position: enum.size - 1,
+               elements: enum)
+        elsif @position >= @elements.size
+          # tail.next
+          copy(position: @elements.size + enum.size,
+               elements: @elements.dup.insert(@position, *enum))
+        elsif @position < 0
+          # head.prev
+          copy(position: 0,
+               elements: @elements.dup.unshift(*enum))
+        else
+          copy(position: @position + enum.size,
+               elements: @elements.dup.insert(@position, *enum))
+        end
+      end
+
+      #   .        .
+      # a b c -> a X c
+      def update(node)
+        enum = unfold(node)
+
+        if @elements.empty?
+          copy(position: 0,
+               elements: enum)
+        elsif @position >= @elements.size
+          # tail.next
+          copy(position: @elements.size,
+               elements: @elements.dup.push(enum.first))
+        elsif @position < 0
+          # head.prev
+          copy(position: 0,
+               elements: @elements.dup.unshift(enum.first))
+        else
+          copy(position: @position,
+               elements: @elements.dup.tap{|e| e[@position] = enum.first })
+        end
+      end
+
+      #   .        .
+      # a b c -> a X Y Z
+      def replace(node = nil)
+        enum = node && unfold(node)
+
+        if @elements.empty?
+          copy(position: 0,
+               elements: enum || unfold(yield(nil)))
+        elsif @position < 0
+          # head.prev
+          copy(position: 0,
+               elements: enum || unfold(yield(@elements.slice(0, 1))))
+        elsif @position >= @elements.size - 1
+          # tail.next
+          copy(position: @elements.size,
+               elements: @elements + enum || unfold(yield(nil)))
+        else
+          copy(position: @position,
+               elements: @elements.slice(0, @position) + enum || unfold(yield(@elements.slice(@position, 1))))
+        end
+      end
+
+      #   .      .
+      # a b c -> a c
+      def delete
+        if @elements.empty?
+          self
+        elsif @position < 0
+          # head.prev
+          copy(position: 0,
+               elements: @elements)
+        elsif @position >= @elements.size - 1
+          # tail.next
+          copy(position: @elements.size - 1,
+               elements: @elements)
+        else
+          copy(position: @position,
+               elements: @elements.dup.tap{|e| e.delete_at(@position) })
+        end
+      end
+
+      # .        .
+      # a b c -> a
+      def truncate
+        if @elements.empty?
+          self
+        elsif @position < 0
+          copy(position: -1,
+               elements: [])
+        else
+          copy(position: @position,
+               elements: @elements[0, @position + 1])
+        end
+      end
+
+    private
+
+      def unfold(node)
+        Array.unfold(node){|seed| (!seed.nil?).maybe([seed, seed.next]) }
+      end
+    end
+
+  end
+end

data/spec/support/szipper/nodel.rb

@@ -0,0 +1,144 @@
+module Fr
+  module SZipper
+
+    class Nodel
+
+      def self.build(node = nil)
+        if node.nil?
+          Model.new(nil, [])
+        else
+          Model.new(Array.unfold(node){|seed| (!seed.nil?).maybe([seed, seed.next]) }, [])
+        end
+      end
+
+      def initialize(node, init)
+        orderd = init.reverse
+        length = init.length
+
+        @node, @init =
+          node, init.map.with_index{|n, k| n.copy(next: orderd[length - k] || node) }
+      end
+
+      def copy(changes = {})
+        Model.new \
+          changes.fetch(:node, @node),
+          changes.fetch(:init, @init)
+      end
+
+      def node
+        if @node.nil?
+          raise Errors::ZipperError,
+            "no node at this position"
+        else
+          @node
+        end
+      end
+
+      #   .      .
+      # a b c -> a b c
+      def prev(phantom = false)
+        if @init.empty?
+          if phantom
+            # todo
+          else
+            raise Errors::ZipperError,
+              "no prev node"
+          end
+        else
+          copy(node: @init.head.copy(next: @node),
+               init: @init.tail)
+        end
+      end
+
+      # .          .
+      # a b c -> a b c
+      def next(phantom = false)
+        if @node.nil?
+          # todo
+        elsif tail? and not phantom
+          raise Errors::ZipperError,
+            "no next node"
+        else
+          copy(node: @node.next,
+               init: @node.cons(@init))
+        end
+      end
+
+      def head?
+        @init.empty?
+      end
+
+      def tail?
+        if @node.nil?
+          @init.empty?
+        else
+          @node.next.nil?
+        end
+      end
+
+      def empty?
+        @node.nil?
+      end
+
+      # .
+      # a b c
+      def head
+        copy(init: [],
+             node: @init.last)
+      end
+
+      #     .
+      # a b c
+      def tail
+        unless tail?
+          self.next.tail
+        else
+          self
+        end
+      end
+
+      #   .        .
+      # a b c -> a b X Y Z c
+      def append(node)
+        copy(node: @node.copy(next: node))
+      end
+
+      #   .              .
+      # a b c -> a X Y Z b c
+      def prepend(node)
+        copy(init: @init + unfold(node))
+      end
+
+      #   .        .
+      # a b c -> a X c
+      def update(node)
+        copy(node: node.copy(next: @node.next))
+      end
+
+      #   .        .
+      # a b c -> a X Y Z
+      def replace(node = nil)
+        copy(node: node || yield(@node))
+      end
+
+      #   .      .
+      # a b c -> a c
+      def delete
+        copy(node: @node.copy(next: @node.next))
+      end
+
+      # .        .
+      # a b c -> a
+      def truncate
+        copy(node: @node.copy(next: nil))
+      end
+
+    private
+
+      def unfold(node)
+        Array.unfold(node){|seed| (!seed.nil?).maybe([seed, seed.next]) }
+      end
+    end
+
+  end
+end