monadt 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c19e86f991142006e0e23f98ec59c2a9780db485
+  data.tar.gz: 52cc959d8eeb05fa7d617d51278ec9b2aed00467
+SHA512:
+  metadata.gz: a06ffff7277f97c3a16652bbb45ed0d0c13a9ad382772a58d372dbdf9b93e2ae45ce9eafdca7612ed29dffc9a5c1513a4be98d2cae09fb128450e2f5142f91d4
+  data.tar.gz: a61dab72be3127c89f11d33ad49af0094838073554719fd2f10de78a6408120302c9818c5843ec71b94c379f43d0348e962dbd5a80591cd545b3e6d6bea23b93

data/lib/monadt/adt.rb

@@ -0,0 +1,33 @@
+AdtPattern = Struct.new :klass, :lambda
+
+def data(*fields)
+  base = if fields.size > 0
+           Struct.new(*fields)
+         else
+           Object
+         end
+  Class.new(base)
+end
+
+Default = data
+
+module Adt
+  def match(o, *cases)
+    m = cases.find do |tpl|
+      tpl.klass == o.class || tpl.klass == Default
+    end
+    params =
+      if m.lambda.arity > 0
+        o.values.take(m.lambda.arity)
+      else
+        []
+      end
+    m.lambda.call(*params)
+  end
+
+  def with(klass, prc=nil, &blk)
+    AdtPattern.new klass, prc || blk
+  end
+end
+
+

data/lib/monadt/either.rb

@@ -0,0 +1,35 @@
+require 'monadt/adt'
+
+module Monadt
+  module Either
+    Left = data :left
+    Right = data :right
+  end
+  class Either::Left
+    def is_left?() true end
+    def is_right?() false end
+    def to_s() "Left(#{left})" end
+  end
+  class Either::Right
+    def is_left?() false end
+    def is_right?() true end
+    def to_s() "Right(#{right})" end
+  end
+
+  class EitherM
+    class << self
+      include Adt
+
+      def bind(m, &blk)
+        match(m,
+          with(Either::Left) { |v| m },
+          with(Either::Right) { |v| blk.call(v) })
+      end
+
+      def return(a)
+        Either::Right.new a
+      end
+    end
+
+  end
+end

data/lib/monadt/list.rb

@@ -0,0 +1,17 @@
+require_relative 'maybe'
+require_relative 'either'
+require_relative 'state'
+require_relative 'reader_state_either'
+
+class ListM
+  class << self
+    def bind(m, &blk)
+      m.flat_map(&blk)
+    end
+
+    def return(a)
+      [a]
+    end
+  end
+end
+

data/lib/monadt/maybe.rb

@@ -0,0 +1,51 @@
+require 'monadt/adt'
+
+module Monadt
+  module Maybe
+    Just = data :value
+    Nothing = data
+  end
+
+  class Maybe::Just
+    def is_nothing?() false end
+    def to_s() "Just #{value}" end
+  end
+  class Maybe::Nothing
+    def is_nothing?() true end
+    def to_s() "Nothing" end
+  end
+
+  class MaybeM
+    class << self
+      include Adt
+
+      def bind(m, &blk)
+        match(m,
+          with(Maybe::Just) { |v| blk.call(v) },
+          with(Maybe::Nothing) { m })
+      end
+
+      def return(a)
+        Maybe::Just.new a
+      end
+    end
+  end
+
+  # like Maybe but nil / not-nill
+  class PresentM
+    class << self
+      def bind(m, &blk)
+        if m.nil?
+          nil
+        else
+          blk.call(m)
+        end
+      end
+
+      def return(a)
+        a
+      end
+    end
+  end
+end
+

data/lib/monadt/monad.rb

@@ -0,0 +1,43 @@
+module Monadt
+  module Internal
+    class MonadObj
+      def initialize(klass, yielder)
+        @yielder = yielder
+        @klass = klass
+      end
+
+      def return(val)
+        @klass.return val
+      end
+
+      def bind(val)
+        @yielder.yield val
+      end
+    end
+  end
+
+  class Monad
+    class << self
+      def do_m(klass, &blk)
+        e = Enumerator.new do |y|
+          m_obj = Internal::MonadObj.new klass, y
+          blk.call(m_obj)
+        end
+        do_m_recur(klass, e)
+      end
+
+      def do_m_recur(klass, e)
+        begin
+          ma = e.next
+        rescue StopIteration => ex
+          return ex.result
+        end
+        klass.bind(ma) do |a|
+          e.feed a
+          do_m_recur(klass, e)
+        end
+      end
+    end
+  end
+end
+

data/lib/monadt/reader.rb

@@ -0,0 +1,16 @@
+module Monadt
+  class ReaderM
+    class << self
+      def bind(m, &blk)
+        ->(e) {
+          v = m.(e)
+          blk.call(e, v)
+        }
+      end
+
+      def return(val)
+        ->(e) { val }
+      end
+    end
+  end
+end

data/lib/monadt/reader_state_either.rb

@@ -0,0 +1,24 @@
+require 'monadt/adt'
+
+module Monadt
+  class ReaderStateEitherM
+    class << self
+      include Adt
+
+      def bind(m, &blk)
+        ->(e, s) {
+          c, s2 = m.(e, s)
+          match(c,
+            with(Either::Left) {|v| [c, s2]},
+            with(Either::Right) {|v|
+              blk.call(v).(e, s2)
+            })
+        }
+      end
+
+      def return(val)
+        ->(e, s) { [EitherM.return(val), s] }
+      end
+    end
+  end
+end

data/lib/monadt/state.rb

@@ -0,0 +1,16 @@
+module Monadt
+  class StateM
+    class << self
+      def bind(m, &blk)
+        ->(st) {
+          v, s = m.(st)
+          blk.call(v).(s)
+        }
+      end
+
+      def return(val)
+        ->(st) { [val, st] }
+      end
+    end
+  end
+end

data/lib/monadt.rb

@@ -0,0 +1,49 @@
+require 'monadt/maybe'
+require 'monadt/either'
+require 'monadt/state'
+require 'monadt/reader_state_either'
+require 'monadt/monad'
+
+module Monadt
+  class Monad
+    class << self
+      def maybe(&blk)
+        do_m(MaybeM, &blk)
+      end
+
+      def present(&blk)
+        do_m(PresentM, &blk)
+      end
+
+      def either(&blk)
+        do_m(EitherM, &blk)
+      end
+
+      def state(&blk)
+        do_m(StateM, &blk)
+      end
+
+      def run_state(initial_state, &blk)
+        prc = state(&blk)
+        prc.(initial_state).first
+      end
+
+      def reader(&blk)
+        do_m(ReaderM, &blk)
+      end
+
+      def run_reader(env, &blk)
+        reader(&blk).(env)
+      end
+
+      def reader_state_choice(&blk)
+        do_m(ReaderStateEitherM, &blk)
+      end
+
+      def run_reader_state_choice(env, initial_state, &blk)
+        reader_state_choice(&blk).(env, initial_state).first
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: monadt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Will Pleasant-Ryan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-25 00:00:00.000000000 Z
+dependencies: []
+description: Functions to create ADTs and do pattern matching, as well as Enumerator
+  based Monad computation
+email: will.ryan@atomicobject.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/monadt.rb
+- lib/monadt/adt.rb
+- lib/monadt/either.rb
+- lib/monadt/list.rb
+- lib/monadt/maybe.rb
+- lib/monadt/monad.rb
+- lib/monadt/reader.rb
+- lib/monadt/reader_state_either.rb
+- lib/monadt/state.rb
+homepage: https://github.com/atomicobject/monadt
+licenses:
+- Apache
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: ADTs and Monads in Ruby
+test_files: []