data.either 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 059a7c25509fac130a6181614b89eea322e83b35
-  data.tar.gz: 6130666ffaaf9a7992dc449f750bd71f1ee84fb3
+  metadata.gz: 08f4e5166ec1ad8d037c1242ad30dc3ea9e60e4c
+  data.tar.gz: f3fc3a10f5aede1bc5b949b664fe65979f619785
 SHA512:
-  metadata.gz: 2ec33c7090e719ef4ed4b7ca8f7df3f0644054a162631641255a76714a44889c04f6c65184aebec2defb5740d32d423b17a68c59f3c150f6f9a031850eb004a5
-  data.tar.gz: 9a3b0f5e6df569a984bae5d9256a7292a77a37bc710ec900d7e98ce97491e51a9ef1ffaa859075b64d2fb2fcc106428b2b6c1c393727ba253d6f96dc19645abc
+  metadata.gz: 5f31fccf30c2341d5bfce564060eddf90172613147663f52d48e6efd301b407ed0716d282c52c6097a7dd10e247d7de5e096b834b0760ea941f796004260c605
+  data.tar.gz: 980bb06448d07169db9c62a1ab80b27a33bca1d7ce56019c5447f28cfadfda392fd9dc2d53aebb925ec0dbcc4a8fe831773bea65b583a77b69c6dea58fe156bd

data/lib/control/monad.rb

@@ -0,0 +1,23 @@
+require 'helper'
+module Control
+  module Functor
+    extend Helper
+    def map
+    end
+  end
+
+  module Monad
+    extend Helper
+    include Functor
+    def >=
+      raise '>= No defined'
+    end
+
+    alias_names([:flat_map], :>=) 
+    
+    def > k
+      self.>= { |_| k }
+    end
+  end
+
+end

data/lib/data.either.rb

@@ -1,9 +1,28 @@
-# a very simple Either
+require 'control/monad'
+
+# The `Either` union type represents values with two possibilities:
+#
+# `Either a b` is either `Left a` or `Right b`
 module Either
+  include Control::Monad
+
+  # Either only contain one value @v
+  # @return [Either]
   def initialize v
     @v = v
   end
 
+  # default `false`, should override in {Left} or {Right}
+  # @return [Boolean]
+  def left?
+    false
+  end
+  # (see #left?)
+  def right?
+    false
+  end
+
+  # get value `a` out from `Right a`, otherwise return `e`
   def get_or_else e
     case self
       when Right
@@ -13,7 +32,13 @@ module Either
     end
   end
 
-  # Functor
+  # overide of Functor's `fmap`, apply function on `Right a`'s value `a`, do nothing if it's `Left e`
+  #
+  # ``` ruby
+  #   Right.new(1).map {|x| x + 1} # => #<Right value=2>
+  #   Left.new(1).map {|x| x + 1} # => #<Left value=1>
+  # ```
+  # @return [Either]
   def map
     case self
     when Right
@@ -22,9 +47,13 @@ module Either
       self
     end
   end
-  
-  alias :fmap :map
-  
+  # the opposit of #map, apply function to `Left e`, do nothing if it's `Right a`
+  #
+  # ``` ruby
+  #   Right.new(1).left_map {|x| x + 1} # => #<Right value=1>
+  #   Left.new(1).left_map {|x| x + 1} # => #<Left value=2>
+  # ```
+  # @return [Either]
   def left_map
     case self
     when Left
@@ -34,6 +63,13 @@ module Either
     end
   end
 
+  # `bimap` accept 2 lambdas, if it's [Right], apply the 2nd lambda, otherwise apply to the first lambda
+  #
+  # ``` ruby
+  #   Right.new(1).bimap ->(x){x-1}, ->(x){x+1} # => 2
+  #   Left.new(1).bimap ->(x){x-1}, ->(x){x+1}) # => 0
+  # ```
+  # @return [Either]  
   def bimap lfn, rfn
     case self
       when Right
@@ -43,8 +79,17 @@ module Either
     end
   end
 
-  # Monad
-  def bind
+  # it override {Monad#>=}, as Haskell's `>>=` method
+  # if it's {Right}, pass the value to #>='s block, and flat the result
+  # of the block.
+  #
+  # when it's {Left}, do nothing
+  # ``` ruby
+  # expect(Right.new(1).>= { |x| Left.new } ).to eq(Left.new)
+  # expect(Left.new(1).>= { |x| Left.new } ).to eq(Left.new(1))
+  # ```
+  # @return [Either]
+  def >=
     case self
     when Right
       yield @v
@@ -53,9 +98,26 @@ module Either
     end
   end
 
-  alias :chain :bind
-  alias :flat_map :bind
+  # similar to Scala's `match` for case class
+  #
+  # will pattern match the value out and pass to matched lambda
+  #
+  # ``` ruby
+  # Right.new(1).when({Right: ->x{x+1} }) # => 2
+  # Right.new(1).when({Left: ->x{x+1}) # => nil
+  # Right.new(1).when({Left: ->x{x+1}, _: ->x{x-1} }) # => 0
+  # ```
+  # @return [Either]
+  def when what
+    current_class = self.class.to_s.to_sym
+    if what.include? current_class
+      what[current_class].(@v)
+    elsif what.include? :_
+      what[:_].(@v)
+    end
+  end
 
+  # @return [String]
   def inspect
     case self
     when Left
@@ -64,13 +126,58 @@ module Either
       "#<Right value=#{@v}>"
     end
   end
+
+  # filter only {Right} value from List of {Either}
+  #
+  # ``` ruby
+  # Either.rights [Left.new(1),Right.new(5), Right.new(2)] # => [5, 2]
+  # ```
+  # @return [value]
+  def self.rights list_of_either
+    list_of_either.select(&:right?)
+      .map { |right| right.get_or_else(nil) }
+  end
+
+  # filter only {Left} value from List of {Either}
+  #
+  # ``` ruby
+  # Either.lefts [Left.new(1),Right.new(5), Right.new(2)] # => [1]
+  # ```
+  # @return [value]
+  def self.lefts list_of_either
+    list_of_either.select(&:left?)
+      .map { |left| left.when({Left: ->l{l}}) }
+  end
+
+  # partion a List of {Either} into a List of 2 List, one contains only {Left}, other contains only {Right}
+  #
+  # ``` ruby
+  # Either.partition [Left.new(1),Right.new(5), Right.new(2)]  # => [[1],[5, 2]]
+  # ```
+  # @return [[l],[r]]
+  def self.partition list_of_either
+    list_of_either.inject([[],[]]) do |acc, x|
+      x.when({
+               Left: ->(l){acc[0].push(l)},
+               Right: ->(r){acc[1].push(r)}
+             })
+      acc
+    end
+  end
 end
 
+
 class Left
-  include Either
+  include Either  
   def initialize v=nil
     @v=v
   end
+
+  # always true
+  # @return [Boolean]
+  def left?
+    true
+  end
   
   def == other
     case other
@@ -84,6 +191,13 @@ end
 
 class Right
   include Either
+  
+  # always true
+  # @return [Boolean]
+  def right?
+    true
+  end
+  
   def == other
     case other
     when Right

data/lib/helper.rb

@@ -0,0 +1,9 @@
+module Helper
+  def alias_names names, m
+    names.each do |name| 
+      define_method(name) do |*args| 
+        self.send(m, *args)
+      end
+    end
+  end    
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data.either
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - Jichao Ouyang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-18 00:00:00.000000000 Z
+date: 2016-08-20 00:00:00.000000000 Z
 dependencies: []
 description: The Either Monad
 email: oyanglulu@gmail.com
@@ -16,7 +16,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/control/monad.rb
 - lib/data.either.rb
+- lib/helper.rb
 homepage: https://github.com/jcouyang/cats.rb
 licenses:
 - MIT