fear 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a628e4319dcc4a672e6a632d6582fdcd9c8bd71
+  data.tar.gz: 3833ced7c33d30fe1111234549b924449a999032
+SHA512:
+  metadata.gz: 56fb816f68a1a85bba4d8819e714c9669b7d2c9972d35a3b4e0c748e16698e2af16687a71cb8099d843800946da2d097fa71045b9c765f8779ef5863ca0a8021
+  data.tar.gz: efa4007136b4b74dbdedddfdfe3e9cd3ccfa5edd4d71d6cd6b554ac0b074298076cdbca2ca3b57a95c81fcf79d4974b9d89a059dd4c5f78855770e100a1134a9

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,32 @@
+inherit_gem:
+  spbtv_code_style: .strict_rubocop.yml
+
+Style/MethodName:
+  Enabled: false
+
+# This configuration was generated by `rubocop --auto-gen-config`
+# on 2015-03-09 00:50:30 +0300 using RuboCop version 0.29.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Enabled: false
+  Max: 133
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ModuleLength:
+  Max: 130
+
+# Offense count: 9
+Style/Documentation:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: Methods.
+Style/SingleLineBlockParams:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.5
+script:
+ - rubocop -D
+ - bundle exec rspec spec
+env: CODECLIMATE_REPO_TOKEN=548312a77df2507c49494d3c6e78cc62631517c39440644c38217d9be1f47e26

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in functional.gemspec
+gemspec
+
+# gem 'codeclimate-test-reporter', group: :test, require: nil

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 TODO: Write your name
+
+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,32 @@
+# Fear
+[![Build Status](https://travis-ci.org/bolshakov/fear.svg?branch=master)](https://travis-ci.org/bolshakov/fear)
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fear'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fear
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/bolshakov/fear/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 a new Pull Request

data/Rakefile

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

data/fear.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'fear/version'
+Gem::Specification.new do |spec|
+  spec.name          = 'fear'
+  spec.version       = Fear::VERSION
+  spec.authors       = ['Tema Bolshakov']
+  spec.email         = ['abolshakov@spbtv.com']
+  spec.summary       = "%q{Ruby port of some Scala's monads.}"
+  spec.description   = "Ruby port of some Scala's monads."
+  spec.homepage      = 'https://github.com/bolshakov/functional'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin\/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^spec\/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'dry-equalizer', '0.2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.1'
+  spec.add_development_dependency 'spbtv_code_style'
+  spec.add_development_dependency 'rubocop-rspec'
+end

data/lib/fear/either.rb

@@ -0,0 +1,145 @@
+module Fear
+  # Represents a value of one of two possible types (a disjoint union.)
+  # An instance of `Either` is either an instance of `Left` or `Right`.
+  #
+  # A common use of `Either` is as an alternative to `Option` for dealing
+  # with possible missing values.  In this usage, `None` is replaced
+  # with a `Left` which can contain useful information.
+  # `Right` takes the place of `Some`. Convention dictates
+  # that `Left` is used for failure and `Right` is used for success.
+  #
+  # For example, you could use `Either<String, Fixnum>` to detect whether a
+  # received input is a `String` or an `Fixnum`.
+  #
+  # @example
+  #   in = Readline.readline('Type Either a string or an Int: ', true)
+  #   result = begin
+  #     Right(Integer(in))
+  #   rescue ArgumentError
+  #     Left(in)
+  #   end
+  #
+  #   puts(
+  #     result.reduce(
+  #       -> (x) { "You passed me the Int: #{x}, which I will increment. #{x} + 1 = #{x+1}" },
+  #       -> (x) { "You passed me the String: #{x}" }
+  #     )
+  #   )
+  #
+  # `Either` is right-biased, which means that `Right` is assumed to be the default case to
+  # operate on. If it is `Left`, operations like `#map`, `#flat_map`, ... return the `Left` value
+  # unchanged:
+  #
+  # @example #map
+  #   Right(12).map { |_| _ * 2) #=> Right(24)
+  #   Left(23).map { |_| _ * 2)  #=> Left(23)
+  #
+  # @example #get_or_else
+  #   Right(12).get_or_else(17) #=> 12
+  #   Left(12).get_or_else(17) #=> 17
+  #
+  #   Right(12).get_or_else { 17 } #=> 12
+  #   Left(12).get_or_else { 17 } #=> 17
+  #
+  # @example #include?
+  #   # Returns true because value of Right is "something" which equals "something".
+  #   Right("something").include?("something") #= true
+  #
+  #   # Returns false because value of Right is "something" which does not equal "anything".
+  #   Right("something").include?("anything") #=> false
+  #
+  #   # Returns false because there is no value for Right.
+  #   Left("something").include?("something") #=> false
+  #
+  # @example #each
+  #   Right(12).each { |x| puts x } # prints "12"
+  #   Left(12).each { |x| puts x } # doesn't print
+  #
+  # @example #map
+  #   Right('ruby').map(&:length) #=> Right(4)
+  #   Left('ruby').map(&:length) #=> Left('ruby')
+  #
+  # @example #flat_map
+  #   Right(12).flat_map { |x| Left('ruby') } #=> Left('ruby')
+  #   Left(12).flat_map { |x| Left('ruby') }  #=> Left(12)
+  #
+  # @example #detect
+  #   Right(12).detect(-1, &:even?) #=> Right(12))
+  #   Right(7).detect(-1, &:even?) #=> Left(-1)
+  #   Left(12).detect(-1, &:even?) #=> Left(-1)
+  #   Left(12).detect(-> { -1 }, &:even?) #=> Left(-1)
+  #
+  # @example #to_a
+  #   Right(12).to_a #=> [12]
+  #   Left(12).to_a #=> []
+  #
+  # @example #to_option
+  #   Right(12).to_option #=> Some(12)
+  #   Left(12).to_option #=> None()
+  #
+  # @example #any?
+  #   Right(12).any? { |v| v > 10 } #=> true
+  #   Right(7).any? { |v| v > 10 }  #=> false
+  #   Left(12).any? { |v| v > 10 }  #=> false
+  #
+  # @example #swap
+  #   left = Left("left")
+  #   right = left.swap #=> Right("left")
+  #
+  # @example #reduce
+  #   result = possibly_failing_operation()
+  #   log(
+  #     result.reduce(
+  #       ->(ex) { "Operation failed with #{ex}" },
+  #       ->(v) { "Operation produced value: #{v}" },
+  #     )
+  #   )
+  #
+  # @example #join_right
+  #   Right(Right(12)).join_right      #=> Right(12)
+  #   Right(Left("flower")).join_right #=> Left("flower")
+  #   Left("flower").join_right        #=> Left("flower")
+  #   Left(Right("flower")).join_right #=> Left(Right("flower"))
+  #
+  # @example #join_left
+  #   Left(Right("flower")).join_left #=> Right("flower")
+  #   Left(Left(12)).join_left        #=> Left(12)
+  #   Right("daisy").join_left        #=> Right("daisy")
+  #   Right(Left("daisy")).join_left  #=> Right(Left("daisy"))
+  #
+  # @see https://github.com/scala/scala/blob/2.12.x/src/library/scala/util/Either.scala
+  #
+  module Either
+    include Dry::Equalizer(:value)
+    include Fear
+
+    def left_class
+      Left
+    end
+
+    def right_class
+      Right
+    end
+
+    def initialize(value)
+      @value = value
+    end
+
+    attr_reader :value
+    protected :value
+
+    module Mixin
+      # @param [any]
+      # @return [Left]
+      def Left(value)
+        Left.new(value)
+      end
+
+      # @param [any]
+      # @return [Right]
+      def Right(value)
+        Right.new(value)
+      end
+    end
+  end
+end

data/lib/fear/failure.rb

@@ -0,0 +1,65 @@
+module Fear
+  class Failure
+    include Try
+    include Dry::Equalizer(:value)
+    include RightBiased::Left
+
+    def initialize(exception)
+      @value = exception
+    end
+
+    attr_reader :value
+    protected :value
+
+    def success?
+      false
+    end
+
+    def get
+      fail value
+    end
+
+    # @return [Try] of calling block
+    def or_else
+      Success.new(yield)
+    rescue => error
+      Failure.new(error)
+    end
+
+    # @return [Failure] self
+    def flatten
+      self
+    end
+
+    # @return [Failure] self
+    # TODO: rename to select
+    def detect
+      self
+    end
+
+    # Applies the given block to exception.
+    # This is like `flat_map` for the exception.
+    #
+    # @yieldparam [Exception]
+    # @yieldreturn [Try]
+    # @return [Try]
+    #
+    def recover_with
+      yield(value).tap do |result|
+        Utils.assert_type!(result, Success, Failure)
+      end
+    rescue => error
+      Failure.new(error)
+    end
+
+    # Applies the given block to exception.
+    # This is like map for the exception.
+    # @return [Try]
+    #
+    def recover
+      Success.new(yield(value))
+    rescue => error
+      Failure.new(error)
+    end
+  end
+end

data/lib/fear/for.rb

@@ -0,0 +1,104 @@
+module Fear
+  # This class provides syntactic sugar for composition of
+  # multiple monadic operations. It supports two such
+  # operations - `flat_map` and `map`. Any class providing them
+  # is supported by `For`.
+  #
+  # @example Option
+  #   For(a: Some(2), b: Some(3)) { a * b } #=> Some(6)
+  #   # If one of operands is None, the result is None
+  #   For(a: Some(2), b: None()) { a * b } #=> None()
+  #   For(a: None(), b: Some(2)) { a * b } #=> None()
+  #
+  # Lets look at first example:
+  #
+  #     For(a: Some(2), b: Some(3)) { a * b }
+  #
+  # would be translated to:
+  #
+  #     Some(2).flat_map do |a|
+  #       Some(3).map do |b|
+  #         a * b
+  #       end
+  #     end
+  #
+  # It works with arrays as well
+  #
+  #     For(a: [1, 2], b: [2, 3], c: [3, 4]) { a * b * c }
+  #       #=> [6, 8, 9, 12, 12, 16, 18, 24]
+  #
+  # would be translated to:
+  #
+  #     [1, 2].flat_map do |a|
+  #       [2, 3].flat_map do |b|
+  #         [3, 4].map do |c|
+  #           a * b * c
+  #         end
+  #       end
+  #     end
+  #
+  class For
+    # Context of block evaluation. It respond to passed locals.
+    #
+    # @example
+    #   context = EvaluationContext.new(foo: 'bar')
+    #   context.foo #=> 'bar'
+    #
+    class EvaluationContext < BasicObject
+      # @param locals [Hash{Symbol => any}]
+      #
+      def initialize(locals)
+        @locals = locals
+      end
+
+      def method_missing(name, *args, &block)
+        if @locals.include?(name) && args.empty? && block.nil?
+          @locals[name]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _)
+        @locals.key?(name)
+      end
+    end
+    private_constant(:EvaluationContext)
+
+    # @param variables [Hash{Symbol => any}]
+    #
+    def initialize(**variables)
+      @variables = variables
+    end
+    attr_reader :variables
+
+    def call(&block)
+      variable_name_and_monad, *tail = *variables
+      execute({}, *variable_name_and_monad, tail, &block)
+    end
+
+    private
+
+    def execute(locals, variable_name, monad, monads, &block)
+      if monads.empty?
+        monad.map do |value|
+          EvaluationContext.new(locals.merge(variable_name => value)).instance_eval(&block)
+        end
+      else
+        monad.flat_map do |value|
+          variable_name_and_monad, *tail = *monads
+          execute(locals.merge(variable_name => value), *variable_name_and_monad, tail, &block)
+        end
+      end
+    end
+
+    module Mixin
+      # @param locals [Hash{Symbol => {#map, #flat_map}}]
+      # @return [{#map, #flat_map}]
+      #
+      def For(**locals, &block)
+        For.new(**locals).call(&block)
+      end
+    end
+  end
+end

data/lib/fear/left.rb

@@ -0,0 +1,52 @@
+module Fear
+  class Left
+    include Either
+    include RightBiased::Left
+
+    # Returns `Left` or `default`.
+    #
+    # @param default [Proc, any]
+    # @return [Either]
+    #
+    def detect(default)
+      Left.new(Utils.return_or_call_proc(default))
+    end
+
+    # @return [Right] value in `Right`
+    #
+    def swap
+      Right.new(value)
+    end
+
+    # @param reduce_left [Proc] the function to apply if this is a `Left`
+    # @return [any] Applies `reduce_left` to the value.
+    #
+    def reduce(reduce_left, _)
+      reduce_left.call(value)
+    end
+
+    # Joins an `Either` through `Right`.
+    #
+    # @return [self]
+    #
+    def join_right
+      self
+    end
+
+    # Joins an `Either` through `Left`.
+    #
+    # This method requires that the left side of this `Either` is itself an
+    # Either type.
+    #
+    # This method, and `join_right`, are analogous to `Option#flatten`
+    #
+    # @return [Either]
+    # @raise [TypeError] if it does not contain `Either`.
+    #
+    def join_left
+      value.tap do |v|
+        Utils.assert_type!(v, Either)
+      end
+    end
+  end
+end

data/lib/fear/none.rb

@@ -0,0 +1,23 @@
+module Fear
+  class None
+    include Option
+    include Dry::Equalizer()
+    include RightBiased::Left
+
+    # Ignores the given block and return self.
+    #
+    # @return [None]
+    #
+    def detect(*)
+      self
+    end
+
+    # Ignores the given block and return self.
+    #
+    # @return [None]
+    #
+    def reject(*)
+      self
+    end
+  end
+end

data/lib/fear/option.rb

@@ -0,0 +1,112 @@
+module Fear
+  # Represents optional values. Instances of `Option`
+  # are either an instance of `Some` or the object `None`.
+  #
+  # The most idiomatic way to use an `Option` instance is to treat it
+  # as a collection or monad and use `map`, `flat_map`, `detect`, or `each`:
+  #
+  # @example
+  #   name = Option(params[:name])
+  #   upper = name.map(&:strip).detect { |n| n.length != 0 }.map(&:upcase)
+  #   puts upper.get_or_else('')
+  #
+  # This allows for sophisticated chaining of `Option` values without
+  # having to check for the existence of a value.
+  #
+  # A less-idiomatic way to use `Option` values is via pattern matching:
+  #
+  # @example
+  #   name = Option(params[:name])
+  #   case name
+  #   when Some
+  #     puts name.strip.upcase
+  #   when None
+  #     puts 'No name value'
+  #   end
+  #
+  # or manually checking for non emptiness:
+  #
+  # @example
+  #   name = Option(params[:name])
+  #   if name.empty?
+  #     puts 'No name value'
+  #   else
+  #     puts name.strip.upcase
+  #   end
+  #
+  # @example #detect
+  #   User.find(params[:id]).detect do |user|
+  #     user.posts.count > 0
+  #   end #=> Some(User)
+  #
+  #   User.find(params[:id]).detect do |user|
+  #     user.posts.count > 0
+  #   end #=> None
+  #
+  #   User.find(params[:id])
+  #     .detect(&:confirmed?)
+  #     .map(&:posts)
+  #     .inject(0, &:count)
+  #
+  # @example #reject
+  #   Some(42).reject { |v| v > 0 } #=> None
+  #   Some(42).reject { |v| v < 0 } #=> Some(42)
+  #   None().reject { |v| v > 0 }   #=> None
+  #
+  # @see https://github.com/scala/scala/blob/2.11.x/src/library/scala/Option.scala
+  #
+  module Option
+    def left_class
+      None
+    end
+
+    def right_class
+      Some
+    end
+
+    # @return [true, false] true if the option is `None`,
+    #   false otherwise.
+    #
+    def empty?
+      is_a?(None)
+    end
+
+    # Returns the option's value if it is nonempty,
+    # or `nil` if it is empty. Useful for unwrapping
+    # option's value.
+    #
+    # @return [Object, nil] the option's value if it is
+    #   nonempty or `nil` if it is empty
+    #
+    # @example
+    #   Option(24).or_nil  #=> 24
+    #   Option(nil).or_nil #=> nil
+    #
+    def or_nil
+      get_or_else { nil }
+    end
+
+    module Mixin
+      # @param value [any]
+      # @return [Some, None]
+      def Option(value)
+        if value.nil?
+          None()
+        else
+          Some(value)
+        end
+      end
+
+      # @return [None]
+      def None
+        None.new
+      end
+
+      # @param value [any] except nil
+      # @return [None]
+      def Some(value)
+        Some.new(value)
+      end
+    end
+  end
+end