data.either 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a823c8ff8fc2ac21beeed40ccdbd4e56ec0d051e
-  data.tar.gz: bd1dfe496dfda2ed7402b54913ed036d2f8236b8
+  metadata.gz: 39e51593595d0e8af8da7020db9ae27881bc7014
+  data.tar.gz: dce8ad4043619d74c38bf961ef94e2d87fafafcb
 SHA512:
-  metadata.gz: 30075c45d751b3a7c6348f72589757e5f07c4039c3f7ab473314e8bfd4d14cc9fe1064c5c46bc49ab021b32dc6f888bed87b06c2e3c4f8cb526c8f9e0f7a85de
-  data.tar.gz: e0b10b73da89ac6cc411d5e6d33586a336270dfe4f0d0d14ea14bf9f737dd993236b40ea6040f20108ae920bef771991c1f0098eb885dd40ebf1740869c671f3
+  metadata.gz: fd7492f59ff49e915d74aeb427755634c8b29c2d72f9d51f1c3446749511800bc61026fdbe797e23ac8ad88ba515e7b1c607d689ed7c61c5dc17daa607557a1b
+  data.tar.gz: bb7074754d721425749f0f11aad709096df68baec575a52ee998cea1c3f65cbb51ed111b13f03225a7ebfd8f91c911a4f0397fddcfecffadaefe6a380a832f03

data/lib/control/monad.rb

@@ -13,7 +13,7 @@ module Control
       raise 'apply No defined'
     end
   end
-  
+
   module Monad
     extend Helper
     include Functor
@@ -23,9 +23,9 @@ module Control
     end
 
     alias_names [:bind, :chain], :flat_map
-    
-    def >> k
-      self.flat_map { |_| k }
+
+    def >>(k)
+      flat_map { |_| k }
     end
   end
 end

data/lib/data.either.rb

@@ -7,10 +7,25 @@ module Either
   include Comparable
   include Control::Monad
   include UnionType
+
+  # try something could raise exception, and wrap value into Right, exception into Left
+  #
+  # @return [Either]
+  # ```ruby
+  # Either::try do
+  #   something_may_raise_error
+  # end
+  # ```
+  def self.try
+    Right.new(yield)
+  rescue => e
+    Left.new(e)
+  end
+  
   # Either only contain one value @v
   # @return [Either]
-  def initialize v=nil
-    @v=v
+  def initialize(v = nil)
+    @v = v
   end
 
   # default `false`, should override in {Left} or {Right}
@@ -18,6 +33,7 @@ module Either
   def left?
     false
   end
+
   # (see #left?)
   def right?
     false
@@ -28,27 +44,26 @@ module Either
   # Right.new(1).get_or_else(2) # => 1
   # Right.new(1) | 2 # => 1
   # ```
-  def get_or_else e
+  def get_or_else(e)
     case self
-      when Right
-        @v
-      else
-        e
+    when Right
+      @v
+    else
+      e
     end
   end
 
-  alias_method :|, :get_or_else
+  alias | get_or_else
 
-  def or_else e
+  def or_else(e)
     case self
-      when Right
-        
-      else
-        e
+    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
@@ -64,6 +79,7 @@ module Either
       self
     end
   end
+
   # the opposit of #map, apply function to `Left e`, do nothing if it's `Right a`
   #
   # ``` ruby
@@ -86,13 +102,13 @@ module Either
   #   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
+  # @return [Either]
+  def bimap(lfn, rfn)
     case self
-      when Right
-        Right.new(rfn.(@v))
-      else
-        Left.new(lfn.(@v))
+    when Right
+      Right.new(rfn.call(@v))
+    else
+      Left.new(lfn.call(@v))
     end
   end
 
@@ -131,9 +147,9 @@ module Either
     end
   end
 
-  alias_method :swap, :~@
-  def each &block
-    bimap(->_{}, &block)
+  alias swap ~@
+  def each(&block)
+    bimap(->(_) {}, &block)
   end
 
   def to_a
@@ -147,17 +163,17 @@ module Either
 
   # 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
+  def <=>(other)
+    other =~ case self
+             when Right
+               { Right: ->(o) { @v <=> o },
+                 Left: ->(_) { 1 } }
+             else
+               { Right: ->(_) { -1 },
+                 Left: ->(o) { @v <=> o } }
+             end
   end
-  
+
   # @return [String]
   def inspect
     case self
@@ -167,7 +183,7 @@ module Either
       "#<Right #{@v.inspect}>"
     end
   end
-  alias_method :to_s, :inspect
+  alias to_s inspect
   class << self
     # filter only {Right} value from List of {Either}
     #
@@ -175,9 +191,9 @@ module Either
     # Either.rights [Left.new(1),Right.new(5), Right.new(2)] # => [5, 2]
     # ```
     # @return [value]
-    def rights list_of_either
+    def rights(list_of_either)
       list_of_either.select(&:right?)
-        .map { |right| right.get_or_else(nil) }
+                    .map { |right| right.get_or_else(nil) }
     end
 
     # filter only {Left} value from List of {Either}
@@ -186,9 +202,9 @@ module Either
     # Either.lefts [Left.new(1),Right.new(5), Right.new(2)] # => [1]
     # ```
     # @return [value]
-    def lefts list_of_either
+    def lefts(list_of_either)
       list_of_either.select(&:left?)
-        .map { |left| left.when({Left: ->l{l}}) }
+                    .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}
@@ -197,30 +213,26 @@ module Either
     # 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)}
-               })
+    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
 
-
 class Left
-  include Either  
+  include Either
 
   # always true
   # @return [Boolean]
   def left?
     true
   end
-  
-  def == other
+
+  def ==(other)
     case other
     when Left
       other.left_map { |v| return v == @v }
@@ -232,14 +244,14 @@ end
 
 class Right
   include Either
-  
+
   # always true
   # @return [Boolean]
   def right?
     true
   end
-  
-  def == other
+
+  def ==(other)
     case other
     when Right
       other.map { |v| return v == @v }

data/lib/helper.rb

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

data/lib/union_type.rb

@@ -1,21 +1,21 @@
 require 'helper'
 module UnionType
   extend Helper
-# 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) =~ ({Left: ->x{x+1}, _: ->x{x-1} }) # => 0
-# ```
-# @return [Either]
-  def when what
+  # 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) =~ ({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)
+      what[current_class].call(@v)
     elsif what.include? :_
-      what[:_].(@v)
+      what[:_].call(@v)
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: data.either
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Jichao Ouyang