rfunc 0.0.1

data/lib/rfunc/seq.rb

@@ -0,0 +1,181 @@
+require "rfunc/option"
+
+module RFunc
+  class Seq
+    extend Forwardable
+
+    def_delegators :@array, :[], :to_s, :to_h, :empty?, :last, :join, :count, :size, :each, :inspect, :all?, :to_a, :to_ary
+
+    def initialize(seq=[])
+      raise "RFunc::Seq must be initialized with an Array.  #{seq.class} is not an Array" if seq.class != Array
+
+      @array = seq
+    end
+
+    def all
+      Seq.new(@array)
+    end
+
+    def <<(el)
+      Seq.new(@array << el)
+    end
+
+    def +(seq2)
+      Seq.new(@array + seq2)
+    end
+
+    def ==(object)
+      object.class == self.class && object.members == @array
+    end
+
+    def <=>(seq_or_array)
+      if seq_or_array.is_a?(Seq)
+        @array <=> seq_or_array.members
+      else
+        @array <=> seq_or_array
+      end
+    end
+
+    def members
+      @array
+    end
+
+    def head
+      raise "RFunc::Seq #{@array} has no head" if @array.size == 0
+      raw_head
+    end
+
+    alias_method :first, :head
+
+    def head_option
+      (h_e = raw_head) ? Some.new(h_e) : None.new
+    end
+
+    alias_method :first_option, :head_option
+
+    def tail_option
+      (tail[0]) ? Some.new(tail) : None.new
+    end
+
+    def tail
+      @tail ||= (t_s = @array[1..-1]) ? Seq.new(t_s) : Seq.new
+    end
+
+    def last_option
+      l = last
+      l ? Some.new(l) : None.new
+    end
+
+    def map(&block)
+      Seq.new(@array.map{|v| yield(v) })
+    end
+
+    def fold(accum, &block)
+      @array.inject(accum) {|a, el| yield(a, el) }
+    end
+
+    def foldr(accum, &block)
+      @array.reverse.inject(accum) {|a, el| yield(a, el) }
+    end
+
+    alias_method :foldl, :fold
+
+    def slice(from, to)
+      Seq.new(@array.slice(from, to))
+    end
+
+    def prepend(el)
+      Seq.new(@array.unshift(el))
+    end
+
+    def append(el)
+      Seq.new(@array.push(el))
+    end
+
+    def reverse
+      Seq.new(@array.reverse)
+    end
+
+    def filter(&block)
+      fold(Seq.new) {|accum, el|
+        if yield(el)
+          accum.append(el)
+        else
+          accum
+        end
+      }
+    end
+
+    def find(&block)
+      RFunc::Option.new(@array.find {|el| yield(el) })
+    end
+
+    def collect(&block)
+      fold(Seq.new([])) {|accum, el| (res = yield(el)) ? accum.append(res) : accum }
+    end
+
+    def collect_first(&block)
+      # more performant than it's prettier version
+      result = nil
+      find {|el| result = yield(el) }
+      result ? RFunc::Some.new(result) : RFunc::None.new
+    end
+
+    def concat(seq_or_array)
+      if seq_or_array.is_a?(Seq)
+        Seq.new(@array.concat(seq_or_array.members))
+      else
+        Seq.new(@array.concat(seq_or_array))
+      end
+    end
+
+    def flat_map(&block)
+      fold(Seq.new) {|accum, el|
+        accum.concat(yield(el))
+      }
+    end
+
+    def flatten
+      Seq.new(@array.flatten)
+    end
+
+    alias_method :for_all?, :all?
+
+    alias_method :for_each, :each
+
+    def slice(start_index, end_index=count)
+      Seq.new(@array.slice(start_index, end_index) || [])
+    end
+
+    def intersect(seq_or_array)
+      if seq_or_array.is_a?(Seq)
+        Seq.new(@array & seq_or_array.members)
+      else
+        Seq.new(@array & seq_or_array)
+      end
+    end
+
+    def take_while(&block)
+      Seq.new(@array.take_while {|r| yield(r) })
+    end
+
+    def take(n)
+      Seq.new(@array.take(n))
+    end
+
+    def sort_by(&block)
+      Seq.new(@array.sort_by {|obj| yield(obj) })
+    end
+
+    def sort(&block)
+      if block_given?
+        Seq.new(@array.sort {|x,y| yield(x,y) })
+      else
+        Seq.new(@array.sort)
+      end
+    end
+
+    private
+      def raw_head; @array[0] end
+  end
+end

data/lib/rfunc/version.rb

@@ -0,0 +1,3 @@
+module RFunc
+  VERSION = "0.0.1"
+end

data/rfunc.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rfunc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rfunc"
+  spec.version       = RFunc::VERSION
+  spec.authors       = ["Paul De Goes"]
+  spec.email         = ["pauldegoes@hotmail.com"]
+  spec.summary       = %q{This gem provides a more functional collection library to Ruby}
+  spec.description   = %q{nada}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "yard"
+end

data/spec/rfunc/option_spec.rb

@@ -0,0 +1,243 @@
+require 'spec_helper'
+
+describe RFunc::Option do
+  describe "#new" do
+    it "returns a Some when a value is supplied" do
+      RFunc::Option.new(1).should == RFunc::Some.new(1)
+    end
+
+    it "returns a None when a value is not supplied" do
+      RFunc::Option.new(nil).should == RFunc::None.new
+    end
+  end
+
+  describe "#map" do
+    context "when Option is Some" do
+      let(:option) { RFunc::Option.new(1) }
+      it "extracts the value from an Option and returns an Option" do
+        option.map {|v| v.should == 1; 2 }.should == RFunc::Some.new(2)
+      end
+    end
+    context "when Option is None" do
+      let(:option) { RFunc::Option.new(nil) }
+      it "doesn't extract the value and returns a None" do
+        option.map {|v| throw "this should not be executed" }.should == RFunc::None.new
+      end
+    end
+  end
+
+  describe "#empty?" do
+    context "for an Option initialized with nil" do
+      it "returns true" do
+        RFunc::Option.new(nil).empty?.should be_true
+      end
+    end
+
+    context "for an None" do
+      it "returns true" do
+        RFunc::None.new.empty?.should be_true
+      end
+    end
+
+    context "for an Some" do
+      it "returns false" do
+        RFunc::Some.new(1).empty?.should be_false
+      end
+    end
+
+    context "for an Option initialized with a value" do
+      it "returns false" do
+        RFunc::Option.new(1).empty?.should be_false
+      end
+    end
+  end
+
+  describe "#flat_map" do
+    context "when the option is a None" do
+      it "does not perform the operation" do
+        expect {
+          RFunc::None.new.flat_map{|v| throw 'should not throw anything' }
+        }.not_to raise_error
+      end
+    end
+    context "when the option is a Some and return type is not a Some of None" do
+      it "raises an error" do
+        expect {
+          RFunc::Some.new(1).flat_map{|v| v + v }
+        }.to raise_error(RFunc::Errors::InvalidReturnType)
+      end
+    end
+    context "when the option is a Some" do
+      it "returns the result of the yield" do
+        RFunc::Some.new(1).flat_map{|v| RFunc::Some.new(v + v) }.should == RFunc::Some.new(2)
+
+        RFunc::Some.new(1).flat_map{|v| RFunc::None.new }.should == RFunc::None.new
+      end
+    end
+
+    describe "#or_else" do
+      context "when the option is a Some" do
+        it "returns the option" do
+          RFunc::Some.new(1).or_else(RFunc::Some.new(2)).get.should == 1
+        end
+      end
+      context "when the option is a None" do
+        context "when the return type of the supplied alternative is valid" do
+          it "returns the option" do
+            RFunc::None.new.or_else(RFunc::Some.new(2)).get.should == 2
+          end
+        end
+        context "when the return type of the supplied alternative is invalid" do
+          it "raises an exception" do
+            expect {
+              RFunc::None.new.or_else(2).get.should == 2
+            }.to raise_error(RFunc::Errors::InvalidReturnType)
+          end
+        end
+      end
+    end
+  end
+
+  describe "#filter" do
+    context "when filter matches" do
+      it "returns a Some" do
+        RFunc::Some.new(1).filter {|el| el == 1}.should == RFunc::Some.new(1)
+      end
+    end
+    context "when filter does not match" do
+      it "returns a None" do
+        RFunc::Some.new(1).filter {|el| el == 2}.should == RFunc::None.new
+      end
+    end
+    context "when None is supplied" do
+      it "returns a None" do
+        RFunc::None.new.filter {|el| el == "foo" }.should == RFunc::None.new
+      end
+    end
+  end
+
+  describe "#filter_not" do
+    context "when filter matches" do
+      it "returns a None" do
+        RFunc::Some.new(1).filter_not {|el| el == 1}.should == RFunc::None.new
+      end
+    end
+    context "when filter does not match" do
+      it "returns a Some" do
+        RFunc::Some.new(1).filter_not {|el| el == 2}.should == RFunc::Some.new(1)
+      end
+    end
+    context "when None is supplied" do
+      it "returns a None" do
+        RFunc::None.new.filter_not {|el| el == "foo" }.should == RFunc::None.new
+      end
+    end
+  end
+
+  describe "#fold" do
+    context "when the option is a None" do
+      it "returns the alternate" do
+        RFunc::None.new.fold(2) {|el|
+          el * el
+        }.should == 2
+      end
+    end
+    context "when the option is a Some" do
+      it "returns the alternate" do
+        RFunc::Some.new(10).fold(2) {|el|
+          el * el
+        }.should == 100
+      end
+    end
+  end
+
+  describe "#flatten" do
+    context "when the option is a None" do
+      it "returns a None" do
+        RFunc::None.new.flatten.should == RFunc::None.new
+      end
+    end
+    context "when the option is a Some[Some]" do
+      it "returns a flattened Some" do
+        RFunc::Some.new(RFunc::Some.new(1)).flatten.should == RFunc::Some.new(1)
+      end
+    end
+    context "when the option is a Some[None]" do
+      it "returns a None" do
+        RFunc::Some.new(RFunc::None.new).flatten.should == RFunc::None.new
+      end
+    end
+  end
+
+  describe "#collect" do
+    context "when the option is a None" do
+      it "returns a None" do
+        RFunc::None.new.collect {|el|
+          case el > 2
+            when true; el * 100
+            else nil
+          end
+        }.should be_a(RFunc::None)
+      end
+    end
+    context "when the option is a Some with on which the provided block returns nil" do
+      it "returns a None" do
+        RFunc::Some.new(2).collect {|el|
+          case el > 2
+            when true; el * 100
+            else nil
+          end
+        }.should be_a(RFunc::None)
+      end
+    end
+    context "when the option is a Some with on which the provided block returns a value" do
+      it "returns a None" do
+        RFunc::Some.new(3).collect {|el|
+          case el > 2
+            when true; el * 100
+            else 100
+          end
+        }.should == RFunc::Some.new(300)
+      end
+    end
+  end
+
+  describe "#for_all" do
+    context "when the option is a None" do
+      it "returns true" do
+        RFunc::None.new.for_all {|el| el == 2}.should == true
+      end
+    end
+    context "when the option is a Some and the result of the provided block is true" do
+      it "returns true" do
+        RFunc::Some.new(2).for_all {|el| el == 2}.should == true
+      end
+    end
+    context "when the option is a Some and the result of the provided block is false" do
+      it "returns false" do
+        RFunc::Some.new(1).for_all {|el| el == 2}.should == false
+      end
+    end
+  end
+
+  describe "#for_each" do
+    context "when the option is a None" do
+      it "does not execute the yield" do
+        count = 0
+
+        RFunc::None.new.for_each {|el| count = 10 }
+
+        count.should == 0
+      end
+    end
+    context "when the option is a Some" do
+      it "not execute the yield with the Option value" do
+        count = 0
+
+        RFunc::Some.new(10).for_each {|el| count = el }
+
+        count.should == 10
+      end
+    end
+  end
+end