rfunc 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ada99d6bda2552bc00c7b03da343402a02c8eb6
+  data.tar.gz: c5ca325b37d69b6ce07f5f559d0d6689c1c91f5a
+SHA512:
+  metadata.gz: 5f791b958bc7def9f8657c9e200037298f190f5d4886f7755813450b487e3521948ead4be2620bacefc64af27fb7508e1750c472e338819f7a18faeca0343528
+  data.tar.gz: 3ee8bca64120fb8ea66c742e3bd12859ce069784ff6c3967dcad97984e74f32f57cb94d7d9a0a161bc2635fe1a2a6a9ef5d42878a3de9a1e43095a2798e5f4a8

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.ruby-gemset

@@ -0,0 +1 @@
+rfunc

data/.ruby-version

@@ -0,0 +1 @@
+2.1.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rfunc.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,25 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, :cmd => 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+
+  # Capybara features specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/features/#{m[1]}_spec.rb" }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Paul De Goes
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,124 @@
+# RFunc
+
+This gem provides access to a functionally oriented collections library.  First release will include Seq and Option support.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rfunc'
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rfunc
+
+## Usage
+
+###RFunc
+The RFunc module provides access to some helper methods that let you form RFunc classes in a less verbosity.
+
+      require "rfunc"
+
+      include RFunc
+
+      Seq([1,2,3]) => RFunc::Seq(1,2,3)
+
+      Option(nil)  => RFunc::None
+
+      Option(1)  => RFunc::Some(1)
+
+
+####RFunc::Seq
+The RFunc::Seq (Sequence) is a replacement for the Ruby Array class which it accepts and provides the following methods:
+
+* [] => access an element of the Seq by index
+
+        RFunc::Seq.new([1])[0] => 1
+
+* head => return the first element of the Seq
+
+        RFunc::Seq.new([1]).head => 1
+
+* head_option => return an Option of the first element of the Seq
+
+        RFunc::Seq.new([1]).head_option => Some(1)
+
+* tail => return all elements of the Seq except the head
+
+        RFunc::Seq.new([1,2,3]).tail => Seq([2,3])
+
+* tail_option => return an Option of all the elements of the Seq
+
+        RFunc::Seq.new([1,2,3]).tail_option => Some(Seq([2,3]))
+
+* map(block) => returns a Seq, the members of which have been operated on by the provided block
+
+        RFunc::Seq.new([1,2,3]).map{|v| v*2 } => Seq([2, 4, 6])
+
+* slice(from, to) => returns a Seq containing the given range
+
+        RFunc::Seq.new([1,2,3,4,5]).slice(2,3) => Seq([2,3,4])
+
+* fold(accum, &block) => returns the value of the yielded block, which takes an accumulator and a Seq element from left to right
+
+        RFunc::Seq.new([1,2,3]).fold(RFunc::Seq.new([])) {|accum, el| accum.append(el + el) } => Seq([2,4,6])
+
+* foldr(accum, &block) => returns the value of the yielded block, which takes an accumulator and a Seq element from right to left
+
+        RFunc::Seq.new([1,2,3]).foldr(RFunc::Seq.new([])) {|accum, el| accum.append(el + el) } => Seq([6,4,2])
+
+* first_option => returns an Option of the first element (Some of None)
+
+        RFunc::Seq.new([1,2]).first_option => Some(1)
+        RFunc::Seq.new([]).first_option => None
+
+* last_option => returns an Option of the last element (Some of None)
+
+        RFunc::Seq.new([1,2]).last_option => Some(2)
+        RFunc::Seq.new([]).last_option => None
+
+* append(el) => returns an RFunc::Seq with the element appended
+
+        RFunc::Seq.new([1]).append(2) => Seq([1,2])
+
+* prepend(el) => returns an RFunc::Seq with the element prepended
+
+        RFunc::Seq.new([2]).prepend(1) => Seq([1,2])
+
+* empty? => returns true or false based on whether or not there are elements in the Seq
+
+        RFunc::Seq.new([]).empty? => true
+        RFunc::Seq.new([1]).empty? => false
+
+* reverse => returns an RFunc::Seq with the elements reversed
+
+        RFunc::Seq.new([1,2,3,4,5]).reverse => Seq([5,4,3,2,1])
+
+* concat => returns an RFunc::Seq with the provided elements appended
+        RFunc::Seq.new([1,2,3]).concat([2,1]) => Seq([1, 2, 3, 2, 1])
+        RFunc::Seq.new([1,2,3]).concat(RFunc::Seq.new([2,1])) => Seq([1, 2, 3, 2, 1])
+
+* flat_map => returns a flattened RFunc::Seq, whose members are derived from operating on each element of the existing Seq
+        RFunc::Seq.new([1,2,3]).flat_map {|el| [el, el -1, el -2] } => Seq([1, 0, -1, 2, 1, 0, 3, 2, 1]>)
+
+## CAVEATES
+
+Ruby is NOT a functional language, nor is it optimized for functional code (tail call recursion for instance).  As a result, this library utilizes native Ruby comprehensions in order to remain performant and useful.  Any libraries built on this code should take the same approach.
+
+## TODO
+
+* Complete Seq library
+* Complete Option library
+  * head
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/rfunc/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rfunc.rb

@@ -0,0 +1,17 @@
+require "rfunc/version"
+require "rfunc/option"
+require "rfunc/seq"
+require "rfunc/errors"
+
+
+module RFunc
+  module_function
+
+  def Seq(a); RFunc::Seq.new(a) end
+
+  def Option(v); RFunc::Option.new(v) end
+
+  def Some(v); RFunc::Some.new(v) end
+
+  def None; RFunc::None.new end
+end

data/lib/rfunc/errors.rb

@@ -0,0 +1,9 @@
+module RFunc
+  module Errors
+    class InvalidReturnType < ArgumentError
+      def initialize(o,expected_type)
+        super("Invalid Return type for #{o.class}.  Expected #{expected_type}")
+      end
+    end
+  end
+end

data/lib/rfunc/option.rb

@@ -0,0 +1,334 @@
+require 'rfunc/errors'
+
+module RFunc
+  class AbstractOption
+    # Initializes the class
+    #
+    # @param value [Any] the initial value of the Option
+    #
+    # @return [AbstractOption] and instance of the class
+    #
+    def initialize(value)
+      @value = value
+    end
+
+    # Comparator that allows one Option to be compared against another
+    # by value
+    #
+    # @return [Boolean] true if the Option values are identical and false
+    #         if not
+    #
+    def ==(object)
+      object.class == self.class && object.get == @value
+    end
+
+    # Extracts the value of the option
+    #
+    # @return [Any] the value of the option
+    def get; @value end
+
+    # Filters the Some by a given function
+    #
+    # @param block [Function] the function which will operate on the
+    #               option's value if present (should return Bool) and
+    #               be used to determine if a Some of None will be
+    #               returned
+    # @return [RFunc::Option] the Option result of the filter
+    #
+    def filter(&block)
+      map {|el| yield(el)}.get_or_else { false } ? self : None.new
+    end
+
+    # Filters the Some by the inverse of a given function
+    #
+    # @param block [Function] the function which will operate on the
+    #               option's value if present (should return Bool) and
+    #               be used to determine if a Some of None will be
+    #               returned
+    # @return [RFunc::Option] the Option result of the filter
+    #
+    def filter_not(&block)
+      map {|el| !yield(el) }.get_or_else { false } ? self : None.new
+    end
+
+    alias_method :find, :filter
+
+    # Tests whether or not an object is an Option
+    #
+    # @param el [Any] the object to test
+    #
+    # @return [Boolean] true if the object is an Option or false if not
+    #
+    def is_option?(el)
+      el.is_a?(AbstractOption)
+    end
+
+    private
+
+      def validated_option_type(r)
+        raise RFunc::Errors::InvalidReturnType.new(r, AbstractOption) if !is_option?(r)
+        r
+      end
+  end
+
+  class Some < AbstractOption
+    def initialize(something)
+      throw "RFunc::Some cannot be initialized with a nil" if something.nil?
+      super(something)
+    end
+
+    # Maintains signiture parity with None.get_or_else
+    #
+    # @param block [Function] the value that would return if the current
+    #               Option was a None
+    #
+    # @return [Any] Option value
+    #
+    def get_or_else(&block)
+      get
+    end
+
+    # Maintains signiture parity with None.or_else
+    #
+    # @param v [Option] the option that would return if the present Option
+    #          were a None
+    #
+    # @return [Option] the current option
+    #
+    def or_else(v)
+      self
+    end
+
+    # Operates on the Option value
+    #
+    # @param block [Function] the function which will be used to operate
+    #        on the Option's value
+    #
+    # @return [Option] the result of the function's operation
+    #         as an Option
+    #
+    def map(&block)
+      Option.new(yield(@value))
+    end
+
+    # Indicates if the Option has a value
+    #
+    # @return [Boolean] false
+    #
+    def empty?
+      false
+    end
+
+    # Applies a function to the value of the Option and
+    # flattens the resulting Option[Option] into a single Option
+    #
+    # @param block [Function] the function which will operate on the
+    #               Option's value (should return an Option)
+    #
+    # @return [RFunc::Option] the Option result of flattening the current
+    #         provided function's option
+    #
+    def flat_map(&block)
+      validated_option_type(yield(get))
+    end
+
+    # Operates on the value of the Option
+    #
+    # @param alternate [Any] the value to return if the Option is a None
+    # @param block [Function] the function which will operate on the
+    #              current Option's value
+    #
+    # @return [Any] the result of applying the supplied block to the current
+    #               Option value
+    #
+    def fold(alternate, &block)
+      yield(get)
+    end
+
+    # Flattens nested Options into a single option
+    #
+    # @return [Option] a Some if the contained value is a Some or a None
+    #         if not
+    #
+    def flatten
+      is_option?(@value) ? @value : self
+    end
+
+    # Operates on the value of the Option if it exists and meets a criteria
+    #
+    # @param block [Function] the block that can be used to modify the value
+    #              (should be a case statement with nil return for non operation)
+    #
+    # @return [Option] the resulting Option containing a value modified by
+    #         the supplied block
+    #
+    def collect(&block)
+      result = yield(@value)
+      result.nil? ? None.new : Some.new(result)
+    end
+
+    # Counts the number of elements for which the block returns true
+    #
+    # @param block [Function] the function that determines whether the
+    #              value should be counted
+    #
+    # @return [Int] 1 if the block returned true for this Option value or 0 if not
+    #
+    def count(&block)
+      yield(value) == true ? 1 : 0
+    end
+
+    # Determines if the current Option value satisfies the supplied block
+    #
+    # @param block [Function] the function that determines whether the
+    #              value satisfies an expectation
+    #
+    # @return [Boolean] true if the block returns true for the value or false if not
+    #
+    def for_all(&block)
+      yield(@value)
+    end
+
+    # Executes the provided block with the current Option value
+    #
+    # @param block [Function] the function that takes the current Option's value
+    #
+    # @return [Nil] nil
+    #
+    def for_each(&block)
+      yield(@value)
+      nil
+    end
+  end
+
+  class None < AbstractOption
+    def initialize
+      super(nil)
+    end
+
+    # Allows for the return of a replacement value
+    #
+    # @param block [Function] a block returning an alternate value
+    #
+    # @return [Any] the result of the supplied block
+    #
+    def get_or_else(&block)
+      yield
+    end
+
+    # Returns an alternative Option for the None
+    #
+    # @param v [Option] the option to be returned
+    #
+    # @return [Option] the provided alternate Option
+    #
+    def or_else(v)
+      validated_option_type(v)
+    end
+
+    # Maintains signiture parity with Some.map
+    #
+    # @param block [Function] the function which would be used to operate
+    #        on the Option's value
+    #
+    # @return [None] a None
+    #
+    def map(&block)
+      self
+    end
+
+    # Indicates if the Option has a value
+    #
+    # @return [Boolean] true
+    #
+    def empty?
+      true
+    end
+
+    # Maintains signiture parity with Some.flat_map
+    #
+    # @param block [Function] the function which will operate on the
+    #               Option's value (should return an Option)
+    #
+    # @return [RFunc::Option] a None
+    #
+    def flat_map(&block)
+      self
+    end
+
+    # Maintains signiture parity with Some.fold
+    #
+    # @param alternate [Any] the value to return if the Option is a None
+    # @param block [Function] the function which will operate on the
+    #              current Option's value
+    #
+    # @return [Any] the alternate
+    #
+    def fold(alternate, &block)
+      alternate
+    end
+
+    # Maintains signiture parity with Some.flatten
+    #
+    # @return [None] self
+    #
+    def flatten
+      self
+    end
+
+
+    # Maintains signiture parity with Some.collect
+    #
+    # @param block [Function] the block that can be used to modify the value
+    #              (should be a case statement with nil return for non operation)
+    #
+    # @return [None] self
+    #
+    def collect(&block)
+      self
+    end
+
+    # Counts the number of elements for which the block returns true
+    #
+    # @param block [Function] the function that determines whether the
+    #              value should be counted
+    #
+    # @return [Int] 0 (there is no value to operate on)
+    #
+    def count(&block)
+      0
+    end
+
+    # Determines if the current Option value satisfies the supplied block
+    #
+    # @param block [Function] the function that determines whether the
+    #              value satisfies an expectation
+    #
+    # @return [Boolean] true because the is no value to violate the supplied block
+    #
+    def for_all(&block)
+      true
+    end
+
+    # Returns nil (no value to execute on)
+    #
+    # @param block [Function] the function that takes the current Option's value
+    #
+    # @return [Nil] nil
+    #
+    def for_each(&block)
+      nil
+    end
+  end
+
+  module Option
+    def self.new(something_or_nothing)
+      case something_or_nothing.nil?
+        when false
+          Some.new(something_or_nothing)
+        else
+          None.new
+      end
+    end
+  end
+end