monad-oxide 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 504855112b6ed7faeb0c45305ed117f1e9950af5cbba9739680e493633ce0b84
+  data.tar.gz: 79491d6d8191a267e64a1fe55f00ef6899d49496a654d9458382b09d40f76f7a
+SHA512:
+  metadata.gz: 3c186a75ca88ae69c1d6fa2e17ad7f7963177a8e6aa28aecf6457c2b549aa4a6ac6c6acb6161b017f0e58d8367f5728bcac032a8e34a82caeadf5ef9d3824e37
+  data.tar.gz: e36391798ab39c82c941b463688cbca7eee416d8d720d7be0eeb428d336b4456ab236fe666b8d80db15a42f1068d3c0466dcc6d24e4b30678edc799e303e6f3f

data/lib/err_spec.rb

@@ -0,0 +1,300 @@
+require 'monad-oxide'
+require 'ok'
+require 'err'
+
+describe MonadOxide::Err do
+
+  # The constructor tests (MonadOxide::Err.new()) are exactly the same as the
+  # helper (MonadOxide.err()).
+  ctor_tests = ->(ctor) {
+    it 'raises a TypeError if not provided an Exception' do
+      expect { ctor.call('foo') }.to raise_error(TypeError)
+    end
+
+    it 'establishes a backtrace for unraised Exceptions' do
+      expect(
+        ctor.call(StandardError.new('foo'))
+          .unwrap_err()
+          .backtrace()
+      ).not_to(be_nil())
+    end
+
+    it 'retains backtraces for raised Exceptions' do
+      begin
+        raise StandardError.new('foo')
+      rescue => e
+        expect(
+          ctor.call(e)
+            .unwrap_err()
+            .backtrace()
+        ).to(be(e.backtrace()))
+      end
+    end
+  }
+
+  context '#initialize' do
+    ctor_tests.call(MonadOxide::Err.method(:new))
+  end
+
+  context 'MonadOxide.err' do
+    ctor_tests.call(MonadOxide.method(:err))
+  end
+
+  context '#and_then' do
+
+    context 'with blocks' do
+      it 'does nothing with the block' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .and_then() {|s| effected = "effect: #{s}"}
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .and_then() { 'bar' }
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'does nothing with the function' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .and_then(->(s) { effected = "effect: #{s}"})
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .and_then(->(_) { 'bar' })
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+
+  end
+
+
+  context '#inspect_err' do
+    context 'with blocks' do
+      it 'applies the data to the block provided' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .inspect_err(->(s) { effected = "effect: #{s}"})
+        expect(effected).to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_err() {|_| 'bar' }
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+
+      it 'returns an Err with the error from the block' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_err() {|_| raise StandardError.new('flagrant') }
+            .unwrap_err()
+            .message()
+          ).to(eq('flagrant'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'applies the data to the function provided' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .inspect_err(->(s) { effected = "effect: #{s}"})
+        expect(effected).to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_err(->(_) { 'bar' })
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+
+      it 'returns an Err with the error from the function' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_err(->(_) { raise StandardError.new('flagrant') })
+            .unwrap_err()
+            .message()
+          ).to(eq('flagrant'))
+      end
+    end
+  end
+
+  context '#inspect_ok' do
+    context 'with blocks' do
+      it 'does nothing with the block' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .inspect_ok() {|s| effected = "effect: #{s}"}
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_ok() { 'bar' }
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'does nothing with the function' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .inspect_ok(->(s) { effected = "effect: #{s}"})
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .inspect_ok(->(_) { 'bar' })
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+  end
+
+
+  context '#map' do
+    context 'with blocks' do
+      it 'does nothing with the block' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .map() {|s| effected = "effect: #{s}"}
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map() { 'bar' }
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'does nothing with the function' do
+        effected = 'unset'
+        MonadOxide.err(StandardError.new('foo'))
+          .map(->(s) { effected = "effect: #{s}"})
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map(->(_) { 'bar' })
+            .unwrap_err()
+            .message()
+          ).to(eq('foo'))
+      end
+    end
+  end
+
+  context '#map_err' do
+    context 'with blocks' do
+      it 'returns an Err if an error is raised in the block' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err() {|_| raise StandardError.new('bar') }
+            .unwrap_err()
+            .message()
+          ).to(eq('bar'))
+      end
+
+      it 'returns a new Err' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err() {|_| StandardErr.new('bar') }
+            .class()
+          ).to(be(MonadOxide::Err))
+      end
+
+      it 'applies the block to the data for the new Ok' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err() {|e| StandardError.new(e.message() + 'bar') }
+            .unwrap_err()
+            .message()
+          ).to(eq('foobar'))
+      end
+
+      it 'requires the mapped value is an Exception still' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err() {|_| 'bar'}
+            .unwrap_err()
+            .class()
+          ).to(be(TypeError))
+      end
+    end
+
+    context 'with Procs' do
+      it 'returns an Err if an error is raised in the function' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err(->(_) { raise StandardError.new })
+            .unwrap_err()
+            .class()
+          ).to(be(StandardError))
+      end
+
+      it 'applies the function to the data for the new Ok' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err(->(e) { StandardError.new(e.message() + 'bar') })
+            .unwrap_err()
+            .message()
+          ).to(eq('foobar'))
+      end
+
+      it 'requires the mapped value is an Exception still' do
+        expect(
+          MonadOxide.err(StandardError.new('foo'))
+            .map_err(->(_) { 'bar' })
+            .unwrap_err()
+            .class()
+          ).to(be(TypeError))
+      end
+    end
+  end
+
+  context '#unwrap' do
+    it 'raises an UnwrapError' do
+      expect {
+        MonadOxide.err(StandardError.new('foo')).unwrap()
+      }.to(raise_error(MonadOxide::UnwrapError))
+    end
+  end
+
+  context '#unwrap_err' do
+    it 'provides the underlying value' do
+      expect(
+        MonadOxide.err(StandardError.new('foo')).unwrap_err().message(),
+      ).to(eq('foo'))
+    end
+  end
+end

data/lib/ok_spec.rb

@@ -0,0 +1,347 @@
+require 'monad-oxide'
+require 'ok'
+require 'err'
+
+describe MonadOxide::Ok do
+
+  context '#and_then' do
+
+    context 'with blocks' do
+      it 'passes the data from the Ok to the block' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|s| MonadOxide.ok(s + 'bar') }
+            .unwrap()
+        ).to(eq('foobar'))
+      end
+
+      it 'converts to an Err if the block raises an error' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|_| raise StandardError.new('flagrant') }
+            .class
+        ).to(be(MonadOxide::Err))
+      end
+
+      it 'converts to an Err if the block returns a non-Result' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|_| 'bar' }
+            .class()
+        ).to(be(MonadOxide::Err))
+      end
+
+      it 'provides a ResultReturnExpectedError in the Err for non-Result returns' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|_| 'bar' }
+            .unwrap_err()
+            .class()
+        ).to(be(MonadOxide::ResultReturnExpectedError))
+      end
+
+      it 'returns the same Ok returned by the block' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|_| MonadOxide.ok('bar') }
+            .unwrap()
+        ).to(eq('bar'))
+      end
+
+      it 'returns the same Err returned by the block' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then() {|_| MonadOxide.err(StandardError.new()) }
+            .unwrap_err()
+            .class()
+        ).to(be(StandardError))
+      end
+    end
+
+    context 'with Procs' do
+      it 'passes the data from the Ok to the function' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(s) { MonadOxide.ok(s + 'bar') })
+            .unwrap()
+        ).to(eq('foobar'))
+      end
+
+      it 'converts to an Err if the function raises an error' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(_) { raise StandardError.new('flagrant') })
+            .class
+        ).to(be(MonadOxide::Err))
+      end
+
+      it 'converts to an Err if the function returns a non-Result' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(_) { 'bar' })
+            .class()
+        ).to(be(MonadOxide::Err))
+      end
+
+      it 'provides a ResultReturnExpectedError in the Err for non-Result returns' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(_) { 'bar' })
+            .unwrap_err()
+            .class()
+        ).to(be(MonadOxide::ResultReturnExpectedError))
+      end
+
+      it 'returns the same Ok returned by the function' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(_) { MonadOxide.ok('bar') })
+            .unwrap()
+        ).to(eq('bar'))
+      end
+
+      it 'returns the same Err returned by the function' do
+        expect(
+          MonadOxide.ok('foo')
+            .and_then(->(_) { MonadOxide.err(StandardError.new()) })
+            .unwrap_err()
+            .class()
+        ).to(be(StandardError))
+      end
+
+    end
+
+  end
+
+  context '#map' do
+    context 'with blocks' do
+      it 'returns an Err if an error is raised in the block' do
+        expect(
+          MonadOxide.ok('foo')
+            .map() {|_| raise StandardError.new('bar') }
+            .unwrap_err()
+            .class()
+          ).to(be(StandardError))
+      end
+
+      it 'returns a new Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map() {|_| 'bar' }
+            .class()
+          ).to(be(MonadOxide::Ok))
+      end
+
+      it 'applies the block to the data for the new Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map() {|s| s + 'bar' }
+            .unwrap()
+          ).to(eq('foobar'))
+      end
+
+      it 'allows nesting of Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map() {|s| MonadOxide.ok(s) }
+            .unwrap()
+            .class()
+          ).to(be(MonadOxide::Ok))
+      end
+
+      it 'allows nesting of Err' do
+        expect(
+          MonadOxide.ok('foo')
+            .map() {|_| MonadOxide.err(StandardError.new('bar')) }
+            .unwrap()
+            .class()
+          ).to(be(MonadOxide::Err))
+      end
+    end
+
+    context 'with Procs' do
+      it 'returns an Err if an error is raised in the function' do
+        expect(
+          MonadOxide.ok('foo')
+            .map(->(_) { raise StandardError.new })
+            .unwrap_err()
+            .class()
+          ).to(be(StandardError))
+      end
+
+      it 'returns a new Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map(->(_) { 'bar' })
+            .class()
+          ).to(be(MonadOxide::Ok))
+      end
+
+      it 'applies the function to the data for the new Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map(->(s) { s + 'bar' })
+            .unwrap()
+          ).to(eq('foobar'))
+      end
+
+      it 'allows nesting of Ok' do
+        expect(
+          MonadOxide.ok('foo')
+            .map(->(s) { MonadOxide.ok(s) })
+            .unwrap()
+            .class()
+          ).to(be(MonadOxide::Ok))
+      end
+
+      it 'allows nesting of Err' do
+        expect(
+          MonadOxide.ok('foo')
+            .map(->(_) { MonadOxide.err(StandardError.new()) })
+            .unwrap()
+            .class()
+          ).to(be(MonadOxide::Err))
+      end
+    end
+  end
+
+  context '#map_err' do
+    context 'with blocks' do
+      it 'does nothing with the block' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .map_err() {|s| effected = "effect: #{s}"}
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .map_err() { 'bar' }
+            .unwrap()
+          ).to(eq('foo'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'does nothing with the function' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .map_err(->(s) { effected = "effect: #{s}"})
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .map_err(->(_) { 'bar' })
+            .unwrap()
+          ).to(eq('foo'))
+      end
+    end
+  end
+
+  context '#inspect_err' do
+    context 'with blocks' do
+      it 'does nothing with the block' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .inspect_err() {|s| effected = "effect: #{s}"}
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_err() { 'bar' }
+            .unwrap()
+          ).to(eq('foo'))
+      end
+    end
+
+    context 'with Procs' do
+      it 'does nothing with the function' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .inspect_err(->(s) { effected = "effect: #{s}"})
+        expect(effected).not_to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_err(->(_) { 'bar' })
+            .unwrap()
+          ).to(eq('foo'))
+      end
+    end
+  end
+
+  context '#inspect_ok' do
+    context 'with blocks' do
+      it 'applies the data to the block provided' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .inspect_ok(->(s) { effected = "effect: #{s}"})
+        expect(effected).to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_ok() {|_| 'bar' }
+            .unwrap()
+          ).to(eq('foo'))
+      end
+
+      it 'returns an Err with the error from the block' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_ok() {|_| raise StandardError.new('flagrant') }
+            .unwrap_err()
+            .class()
+          ).to(be(StandardError))
+      end
+    end
+
+    context 'with Procs' do
+      it 'applies the data to the function provided' do
+        effected = 'unset'
+        MonadOxide.ok('foo')
+          .inspect_ok(->(s) { effected = "effect: #{s}"})
+        expect(effected).to(eq('effect: foo'))
+      end
+
+      it 'does not change the underlying data' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_ok(->(_) { 'bar' })
+            .unwrap()
+          ).to(eq('foo'))
+      end
+
+      it 'returns an Err with the error from the function' do
+        expect(
+          MonadOxide.ok('foo')
+            .inspect_ok(->(_) { raise StandardError.new('flagrant') })
+            .unwrap_err()
+            .class()
+          ).to(be(StandardError))
+      end
+    end
+  end
+
+  context '#unwrap' do
+    it 'provides the underlying value' do
+      expect(MonadOxide.ok('foo').unwrap()).to(eq('foo'))
+    end
+  end
+
+  context '#unwrap_err' do
+    it 'raises an UnwrapError' do
+      expect {
+        MonadOxide.ok('foo').unwrap_err()
+      }.to(raise_error(MonadOxide::UnwrapError))
+    end
+  end
+end

data/lib/result_spec.rb

@@ -0,0 +1,30 @@
+require 'monad-oxide'
+require 'result'
+
+describe MonadOxide::Result do
+  context '#initialize' do
+    it 'is protected from external consumption' do
+      expect { MonadOxide::Result.new('hi') }.to(raise_exception(NoMethodError))
+    end
+  end
+
+  context '#flatten' do
+    it 'returns itself when the Result is already flat' do
+      r = MonadOxide.ok('flat')
+      expect(r.flatten()).to(be(r))
+    end
+
+    it 'returns the inner result' do
+      inner = MonadOxide.ok('inner')
+      outer = MonadOxide.ok(inner)
+      expect(outer.flatten()).to(be(inner))
+    end
+
+    it 'returns the innermost result regardless of nesting' do
+      innermost = MonadOxide.ok('innermost')
+      inner = MonadOxide.ok(innermost)
+      outer = MonadOxide.ok(inner)
+      expect(outer.flatten()).to(be(innermost))
+    end
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: monad-oxide
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Logan Barnett
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Monad-Oxide is a port of Rust's built-in monads from std, such as Result and
+  Option. This enables better reasoning about error handling and possibly missing
+  data.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/err_spec.rb
+- lib/ok_spec.rb
+- lib/result_spec.rb
+homepage: 
+licenses:
+- Apache-2.0
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Ruby port of Rust's Result and Option.
+test_files: []