data.either 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08f4e5166ec1ad8d037c1242ad30dc3ea9e60e4c
-  data.tar.gz: f3fc3a10f5aede1bc5b949b664fe65979f619785
+  metadata.gz: 9c33caadee9fe0b72c04d63bb00cb0bcd6b80cbe
+  data.tar.gz: dcfc0d9d6ac4f8203656e9dca564ce4b0b07f230
 SHA512:
-  metadata.gz: 5f31fccf30c2341d5bfce564060eddf90172613147663f52d48e6efd301b407ed0716d282c52c6097a7dd10e247d7de5e096b834b0760ea941f796004260c605
-  data.tar.gz: 980bb06448d07169db9c62a1ab80b27a33bca1d7ce56019c5447f28cfadfda392fd9dc2d53aebb925ec0dbcc4a8fe831773bea65b583a77b69c6dea58fe156bd
+  metadata.gz: 2aaa80d55efd1a9b9214cdfe61008873ea29558c9f3c9893de69cb9a5528fbbebed7683cb094913ab8981274ee0a6e70161448e4b6521791f0ed685ba971051a
+  data.tar.gz: c421608cce3d4488011e087533814890c3eb84949fcd37b06040ce03d1300fbdccbccf2afa5d77ce72b0675e2ec380f7972f4a582085857090b9272b5ba6e524

data/lib/control/monad.rb

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

data/lib/data.either.rb

@@ -4,6 +4,7 @@ require 'control/monad'
 #
 # `Either a b` is either `Left a` or `Right b`
 module Either
+  include Comparable
   include Control::Monad
 
   # Either only contain one value @v
@@ -23,6 +24,10 @@ module Either
   end
 
   # get value `a` out from `Right a`, otherwise return `e`
+  # ```ruby
+  # Right.new(1).get_or_else(2) # => 1
+  # Right.new(1) | 2 # => 1
+  # ```
   def get_or_else e
     case self
       when Right
@@ -32,6 +37,18 @@ module Either
     end
   end
 
+  alias_method :|, :get_or_else
+
+  def or_else e
+    case self
+      when Right
+        
+      else
+        e
+    end
+  end
+
+  
   # overide of Functor's `fmap`, apply function on `Right a`'s value `a`, do nothing if it's `Left e`
   #
   # ``` ruby
@@ -79,17 +96,17 @@ module Either
     end
   end
 
-  # it override {Monad#>=}, as Haskell's `>>=` method
-  # if it's {Right}, pass the value to #>='s block, and flat the result
+  # it override {Monad#flat_map}, as Haskell's `>flat_map` method
+  # if it's {Right}, pass the value to #flat_map'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))
+  # expect(Right.new(1).flat_map { |x| Left.new } ).to eq(Left.new)
+  # expect(Left.new(1).flat_map { |x| Left.new } ).to eq(Left.new(1))
   # ```
   # @return [Either]
-  def >=
+  def flat_map
     case self
     when Right
       yield @v
@@ -101,11 +118,10 @@ module Either
   # similar to Scala's `match` for case class
   #
   # will pattern match the value out and pass to matched lambda
-  #
-  # ``` ruby
+  # ```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
+  # Right.new(1) =~ ({Left: ->x{x+1}, _: ->x{x-1} }) # => 0
   # ```
   # @return [Either]
   def when what
@@ -117,6 +133,52 @@ module Either
     end
   end
 
+  alias_method :match, :when
+  alias_method :=~, :when
+
+  # swap type of [Either]
+  #
+  # ```ruby
+  #  ~Right.new(1) # => Left.new(1)
+  #  ~Left.new(2) # => Right.new(2)
+  # ```
+  # @return [Either]
+  def ~@
+    case self
+    when Right
+      Left.new @v
+    else
+      Right.new @v
+    end
+  end
+
+  alias_method :swap, :~@
+  def each &block
+    bimap(->_{}, &blcok)
+  end
+
+  def to_a
+    case self
+    when Right
+      [@v]
+    else
+      []
+    end
+  end
+
+  # comparable
+  # - Left < Right
+  def <=> other
+    case self
+    when Right
+      other =~ {Right: ->o{ @v <=> o},
+                Left: ->_{1}}
+    else
+      other =~ {Right: ->_{ -1 },
+                Left: ->o{ @v <=> o}}
+    end
+  end
+  
   # @return [String]
   def inspect
     case self
@@ -127,43 +189,46 @@ module Either
     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
+  class << self
+    # 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 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
+    # filter only {Left} value from List of {Either}
+    #
+    # ``` ruby
+    # Either.lefts [Left.new(1),Right.new(5), Right.new(2)] # => [1]
+    # ```
+    # @return [value]
+    def 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
+    # 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 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
+  
 end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: data.either
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Jichao Ouyang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-20 00:00:00.000000000 Z
+date: 2016-08-22 00:00:00.000000000 Z
 dependencies: []
 description: The Either Monad
 email: oyanglulu@gmail.com