result-monad 0.1.4 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d7a2508b248f8d999b8b3c4566001f102399d07e
-  data.tar.gz: e1243b101da496354f6e6bd0aaedbd0397ab559f
+  metadata.gz: a15b6b9f028996e96deaa63cc18edb7e314e1043
+  data.tar.gz: 7a45714caaf085a3c3d11ad4b08525758dcf2daa
 SHA512:
-  metadata.gz: a31672ae7159a4257786b74a766aaba389ff2050dfdce92f5ed555e388c3f13c2a34dff8ca18b915f7db6cee271d4b13ab80c329c67800b1a39d4dfec21275ac
-  data.tar.gz: b877510e55b8460dd0a60f45318c99d03ff916829655f1b6cf8129a6c114b3136eebd59ff9724bc6f3d632bbc2a769ed2a9ef167b7deac3f950251d5eb30e20b
+  metadata.gz: d80f7dbfaedf0fb7ebf4bf1d483757d792d455f572f4bb51a0f29a9b1bead9924a16f2178e66e69fef24ab2f0647716cee783c6990189331dbbbf2083ab7219b
+  data.tar.gz: a10d6be8ae576889ea88c4190f7784974de3c372c61b20eb49fdc9289e2b2e977cb161e952f1f8e0c9a06ab9b21b52cc1bf203c1378dc5e16433fe397b432875

data/README.md

@@ -87,112 +87,6 @@ x.map {|i| i / 10}
 #=>Result<Error(divided by 0)>
 ```
 
-#### Performing actions in sequence
-
-```ruby
-x = Ok(5)
-y = Error(99)
-z = Ok(25)
-
-# In this case, imagine x and z as successful actions, whereas y is an unsuccessful action.
-
-x & y & z #=> Result<Error(99)>
-
-```
-
-#### Real World Scenario
-
-Lets say we are using an external library to read data from a file over FTP,
-write it to a local file, and then delete the file on the FTP server.  Some things to note:
-
-* We use overloaded operator & to chain on Ok
-* Every call to any outside library, even standard library functions are either in a `map` block which
-  gets Captured or they are themselves Captured
-* No independent action (as in someone calling `copy_file` directly) will execute without its requirements being met.
-* A shortcut to creating an Error value based on some condition, as well as capturing errors generated from testing the
-  condition can be seen in `ensure_file`.  Any exceptions raised by File.exist?, as well as our condition not being met
-  are captured as Error
-
-```ruby
-require 'net/ftp'
-
-class SensitiveFileFTP
-  def initialize(server_uri)
-    @server_uri = server_uri
-  end
-  
-  def transfer_and_delete(file_name)
-    login & # "&" chains on Ok
-    copy_file(file_name) & 
-    ensure_file(file_name) & 
-    delete_remote_file(file_name)
-  end
-  
-  def ftp
-    @ftp ||= Capture { Net::FTP.new(@server_uri) }
-  end
-  
-  def login
-    ftp.map(&:login)
-  end
-  
-  def copy_file(source)
-    ftp.map { |f| f.getbinaryfile(source) }
-  end
-  
-  def ensure_file(name)
-    Capture { raise "Can not verify local copy of file" unless File.exist?(name) }
-  end
-  
-  def delete_remote_file(name)
-    ftp.map {|f| f.delete(name) }
-  end
-  
-  def delete_local_file(name)
-    Capture { File.delete(name) }
-  end
-end
-
-ftp = SensitiveFileFTP.new('speedtest.tele2.net')
-ftp.transfer_and_delete("5MB.zip")
-```
-
-`transfer_and_delete` can return numerous errors but there is no way for this code to raise an exception.  Exceptions
-raised in `map` or `map!` are caught and expressed as `Error`.
-
-#### Conditionally executing code
-
-Using the example above, say we wanted to find and delete the file if we may have accidentally created it.
-This wouldn't be a sensible way of solving this problem, but this illustrates a use case for result base conditionals.
-
-```ruby
-ftp = SensitiveFileFTP.new('speedtest.tele2.net')
-ftp.transfer_and_delete("5MB.zip").or_else do
-  ftp.delete_local_file("5MB.zip")
-end
-
-# or lets say we wanted to log a success if it worked
-
-ftp.transfer_and_delete("5MB.zip").and_then do
-  log "Did the thing!"
-end
-```
-
-
-## What's next
-
-* More documentation and refined use cases for existing methods, like `map_err`, `map!`, and `|`
-
-* refine methods of conditionally executing blocks.  Should the return values be wrapped in results, or should we trust
-  the users to do it?
-
-* Right now, the only computational state kept is the last good result or the first error that occurred.
-This may not be ideal or appropriate.  We also don't join errors up the chain, so it is possible to end up with
-something like this: `Error(Error(Error(Error(Error(...)))))`.  We either need to find a way to join, and perhaps
-store the errors as some aggregate object, or we need to provide utilities for probing for information on the different
-nested errors.  I think it may be appropriate to kep a collection of errors, and ensure that we don't nest.
-
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/result-monad.rb

@@ -1,156 +1,30 @@
-require "result-monad/version"
-require 'byebug'
+require 'result-monad/version'
+require 'result-monad/result_error'
+require 'result-monad/result_methods'
+require 'result-monad/error'
+require 'result-monad/ok'
 
 def Error(error)
-  Result.error(error)
+  Error.new(error)
 end
 
 def Ok(value)
-  Result.ok(value)
+  Ok.new(value)
 end
 
-def Capture
-  begin
-    Ok(yield).join!
-  rescue StandardError => e
-    Error(e).join!
+def Test(o, e)
+  if yield
+    Ok(o)
+  else
+    Error(e)
   end
 end
 
-class Result
-  require 'result-monad/error'
-  require 'result-monad/ok'
-
-  def initialize(m)
-    @m = m
-  end
-
-  def ok?
-    @m.is_a? Ok
-  end
-
-  def error?
-    @m.is_a? Error
-  end
-
-  def map!(&block)
-    if ok?
-      @m.map!(&block)
-      self.lift!(val)
-    else
-      self
-    end
-  end
-
-  def map_err!(&block)
-    if error?
-      @m.map!(&block)
-    else
-      self
-    end
-  end
-
-  def map(&block)
-    if ok?
-      @m.map(&block)
-    else
-      self
-    end
-  end
-
-  def map_err(&block)
-    if error?
-      @m.map(&block)
-    else
-      self
-    end
-  end
-
-  def join!
-    if ok? && val.is_a?(Result)
-      lift!(val)
-    end
-    self
-  end
-
-  def lift!(other)
-    @m = (self & other.join!).instance_variable_get(:"@m")
-    self
-  end
-
-  def unwrap
-    raise ResultError.new(self), "Attempted to unwrap an error" if @m.is_a? Error
-    val
-  end
-
-  def and(other)
-    error? ? self : other
-  end
-  alias_method :&, :and
-
-  def or(other)
-    error? ? other : self
-  end
-  alias_method :|, :or
-
-  def and_then(&block)
-    Capture {block.call} if ok?
-  end
-
-  def or_else(&block)
-    Capture {block.call} if error?
-  end
-
-  def unwrap_or(cons)
-    ok? ? unwrap : cons
-  end
-
-  def map_when(kind, &block)
-    @m.map(&block) if val.is_a?(kind)
-    self
-  end
-
-  def do_when(kind, &block)
-    Capture { block.call } if val.is_a?(kind)
-    self
-  end
-
-  def raise_or_return!
-    if ok?
-      return val
-    else
-      raise val
-    end
-  end
-
-  # Constructors
-  def self.error(error)
-    new(Error.new(error))
-  end
-
-  def self.ok(result)
-    new(Ok.new(result))
-  end
-
-  def to_s
-    @m.to_s
-  end
-
-  def inspect
-    "Result<#{self}>"
-  end
-
-  private
-
-  def val
-    @m.instance_variable_get(:"@value")
+def Capture
+  begin
+    Ok(yield)
+  rescue StandardError => e
+    Error(e)
   end
 end
 
-class ResultError < StandardError
-  attr_reader :result
-
-  def initialize(result)
-    @result = result
-  end
-end

data/lib/result-monad/error.rb

@@ -1,27 +1,13 @@
 class Error
-  def initialize(value)
-    @value = value
-  end
 
-  def map!(&block)
-    @value = Capture {block.call(@value)}
-    self
-  end
+  include ResultMethods
 
-  def map(&block)
-    capture_as_error { block.call(@value) }
+  def initialize(err)
+    @err = err
   end
 
-  def to_s
-    "Error(#{@value})"
+  def handle_result(success_handler, failure_handler)
+    failure_handler.call(@err)
   end
 
-  private
-  def capture_as_error
-    begin
-      Error(yield)
-    rescue StandardError => e
-      Error(e)
-    end
-  end
 end

data/lib/result-monad/ok.rb

@@ -1,18 +1,13 @@
 class Ok
-  def initialize(value)
-    @value = value
-  end
 
-  def map!(&block)
-    @value = Capture { block.call(@value) }
-    self
-  end
+  include ResultMethods
 
-  def map(&block)
-    Capture { block.call(@value) }
+  def initialize(result)
+    @result = result
   end
 
-  def to_s
-    "Ok(#{@value})"
+  def handle_result(success_handler, failure_handler)
+    success_handler.call(@result)
   end
+
 end

data/lib/result-monad/result_error.rb

@@ -0,0 +1,2 @@
+class ResultError < StandardError
+end

data/lib/result-monad/result_methods.rb

@@ -0,0 +1,79 @@
+module ResultMethods
+  #TODO:
+  # map! Not necessarily a good idea
+  # map_unsafe! See above
+  def map
+    handle_result(
+      Proc.new {|val| Capture { yield(val) } },
+      Proc.new {|err| self }
+    )
+  end
+
+  def map_err
+    handle_result(
+      Proc.new {|val| self },
+      Proc.new {|val| Capture { yield(val) } }
+    )
+  end
+
+  def join
+    handle_result(
+      Proc.new { |x| x.is_a?(Ok) || x.is_a?(Error) ? x.join : self },
+      Proc.new { |x| self }
+    )
+  end
+
+  def flat_map(&block)
+    (map &block).join
+  end
+
+  def map_unsafe
+    handle_result(
+      Proc.new {|val| yield(val) },
+      Proc.new {|err| self }
+    )
+  end
+
+  def and_then
+    handle_result(
+      Proc.new {|val| yield(val); self},
+      Proc.new {|err| self}
+    )
+  end
+
+  def or_else
+    handle_result(
+      Proc.new {|val| self},
+      Proc.new {|err| yield(val); self}
+    )
+  end
+
+  def flat_map_unsafe(&block)
+    (map_unsafe &block).join
+  end
+
+  def unwrap
+    handle_result(
+      Proc.new {|val| val},
+      Proc.new do |err|
+        if err.is_a? Exception
+          raise err
+        else
+          raise ResultError.new, "#{err}"
+        end
+      end
+    )
+  end
+
+  def ok?
+    is_a? Ok
+  end
+
+  def error?
+    is_a? Error
+  end
+
+  def to_s
+    "#{ self.class.name }: #{@result}"
+  end
+end

data/lib/result-monad/version.rb

@@ -1,3 +1,3 @@
 class Result
-  VERSION = "0.1.4"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: result-monad
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Zachary Daniel
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -88,6 +88,8 @@ files:
 - lib/result-monad.rb
 - lib/result-monad/error.rb
 - lib/result-monad/ok.rb
+- lib/result-monad/result_error.rb
+- lib/result-monad/result_methods.rb
 - lib/result-monad/version.rb
 - result-monad.gemspec
 homepage: http://gitlab.com/zachdaniel/result-monad