obfusk 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab52e4ba4fbe81a4bd33c4a117a3c07affd52145
-  data.tar.gz: c66dbc2b709774495e2e62eb7caa602a62d44e85
+  metadata.gz: 4c4bd6bb10352b9c18b779e647b5acfd1c3877db
+  data.tar.gz: c6f6309c765f5c519e155286323bbbb9d82590ff
 SHA512:
-  metadata.gz: fd8d2b17d29df81221aea8c51ccbe9e868e23092ae0a85964b912f18493152103192ac36f3caf03b13865783960dd747cc38f2f1b04e99ce82ce4a4ab1f20399
-  data.tar.gz: 2a2dfba314ab304371df55b379e898eb00de023c2141d6e335df8f963463f4929289279a40cc4176c56446b980b8a4226d213a5b1c51b3480d30fa3a496471f6
+  metadata.gz: a4dbae8abf373e372b28bbba4b913e2afcc6045c0f4a2480dc8164fabcdbeaee09685530075828bf2b35de45ba62145c7f7b5f2d0769d5141edbd2cbf4b611e4
+  data.tar.gz: d404720017b40471a4c8abf19ccf6e2ee5261fbe1f43d3763e88992d027b5af3148911a0f6a92ec171917c293087aa33276e16d4ad66bcef68bb53dd55e1152f

data/README.md

@@ -2,10 +2,10 @@
 
     File        : README.md
     Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-    Date        : 2014-06-16
+    Date        : 2014-06-18
 
     Copyright   : Copyright (C) 2014  Felix C. Stegerman
-    Version     : v0.1.1
+    Version     : v0.1.2
 
 []: }}}1
 
@@ -27,10 +27,23 @@ class Foo
   constructor :Baz, :value
 end
 
-x = Foo.Bar()
+x = Foo.Bar
 y = Foo.Baz 99
 
-puts y.value # => 99
+y.value # => 99
+
+x.match Bar: -> (_) { "it's a bar!" },
+        Baz: -> (z) { "it's a baz with value: #{z.value}" }
+# => "it's a bar!"
+```
+
+```ruby
+require 'obfusk/atom'
+
+x = Obfusk.atom 42
+x._ # => 42
+10.times { x.swap! { |v| v + 1 } }
+x._ # => 53
 ```
 
 ```ruby
@@ -67,7 +80,7 @@ require 'obfusk/monad'
 
 class Foo
   include Obfusk::Monad
-  def self.return(x)
+  def self.mreturn(x)
     # ...
   end
   def self.bind_pass(m, &b)
@@ -78,20 +91,21 @@ end
 f = -> x { '...' }
 g = -> y { '...' }
 
-Foo.pipeline Foo.new('...'), f, g
+Foo.new('...').pipeline f, g
 ```
 
 ```ruby
 require 'obfusk/monads'
+ms = Obfusk::Monads
 
-x = Obfusk.Nothing
-y = Obfusk.Just 42
+x = ms.Nothing
+y = ms.Just 42
 
 x.bind(y)
-# => Obfusk.Nothing
+# => ms.Nothing
 
-Obfusk.Left "oops"
-Obfusk.Right 37
+ms.Left "oops"
+ms.Right 37
 ```
 
 ...

data/lib/obfusk/adt.rb

@@ -2,7 +2,7 @@
 #
 # File        : obfusk/adt.rb
 # Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-# Date        : 2014-06-15
+# Date        : 2014-06-17
 #
 # Copyright   : Copyright (C) 2014  Felix C. Stegerman
 # Licence     : LGPLv3+
@@ -17,6 +17,8 @@ module Obfusk
 
   # Algebraic Data Type
   module ADT
+    module Constructor; end
+
     include Comparable
 
     def self.included(base)
@@ -30,13 +32,24 @@ module Obfusk
     end
 
     module ClassMethods
+      # record constructor; call with name of constructor and hash of
+      # keys to values
+      def new(*a, &b)
+        ancestors.include?(::Obfusk::ADT::Constructor) ? super : _new(*a, &b)
+      end
+
+      def _new(ctor, data = {}, &b)
+        c = constructors[ctor]
+        c[:method].call *data.values_at(*c[:keys]), &b
+      end
+
       # duplicate constructors for subclasses
       def inherited(subclass)
         return if ::Obfusk::ADT_Meta__[:inheriting].last
         ctors = constructors
         subclass.class_eval do
           ctors.each_pair do |k,v|
-            constructor v[:ctor_name], *v[:ctor_keys], &v[:ctor_block]
+            constructor v[:name], *v[:keys], &v[:block]
           end
         end
       end
@@ -56,17 +69,17 @@ module Obfusk
           end
         end
         ctor.class_eval do
-          attr_accessor :ctor, :ctor_name, :ctor_keys
-          keys_.each { |k| define_method(k) { @data[k] } }
+          include ::Obfusk::ADT::Constructor
+          keys_.each { |k| define_method(k) { __adt_data__[k] } }
           define_method(:initialize) do |guard, ctor, *values, &f|
             raise ArgumentError, 'for internal use only!' \
               unless guard == :for_internal_use_only
             if !b && (k = keys_.length) != (v = values.length)
               raise ArgumentError, "wrong number of arguments (#{v} for #{k})"
             end
-            data  = Hash[keys_.zip values]
+            data  = Hash[keys_.zip values].freeze
             @ctor = ctor ; @ctor_name = name_ ; @ctor_keys = keys_
-            @data = b ? b[self, data, values, f] : data
+            @data = b ? b[self, data, values, f].freeze : data
           end
         end
         class_eval do
@@ -81,8 +94,8 @@ module Obfusk
             define_method(name_)           { |*values,&b| f[values,b] }
           end
           constructors[name_] = {
-            ctor: ctor, method: method(name_),
-            ctor_name: name_, ctor_keys: keys_, ctor_block: b
+            ctor: ctor, method: method(name_), name: name_,
+            keys: keys_, block: b
           }
         end
         name_
@@ -95,11 +108,11 @@ module Obfusk
       end
 
       # import the constructors into another namespace
-      def import_constructors(scope)
+      def import_constructors(scope, const = true)
         constructors.each_pair do |k,v|
           m = method k
           scope.define_singleton_method(k) { |*a,&b| m[*a,&b] }
-          scope.const_set k, v[:ctor]
+          scope.const_set k, v[:ctor] if const
         end
       end
 
@@ -113,8 +126,27 @@ module Obfusk
       end
     end
 
+    # clone
+    def clone(merge_data = {})
+      merge_data.empty? ? self :
+        self.class.superclass.new(__adt_ctor_name__,
+                                  __adt_data__.merge(merge_data))
+    end
+
+    def __adt_ctor__
+      @ctor
+    end
+
+    def __adt_ctor_name__
+      @ctor_name
+    end
+
+    def __adt_ctor_keys__
+      @ctor_keys
+    end
+
     # the data
-    def _data
+    def __adt_data__
       @data
     end
 
@@ -122,7 +154,7 @@ module Obfusk
     def ==(rhs)
       rhs.is_a?(::Obfusk::ADT) &&
         self.class.superclass == rhs.class.superclass &&
-        ctor == rhs.ctor && _eq_data(rhs)
+        __adt_ctor__ == rhs.__adt_ctor__ && _eq_data(rhs)
     end
 
     # equal and of the same type?
@@ -135,16 +167,18 @@ module Obfusk
       return nil unless rhs.is_a?(::Obfusk::ADT) &&
                         self.class.superclass == rhs.class.superclass
       k = self.class.superclass.constructors.keys
-      ctor != rhs.ctor ? k.index(ctor_name) <=> k.index(rhs.ctor_name) :
+      __adt_ctor__ != rhs.__adt_ctor__ ?
+        k.index(__adt_ctor_name__) <=> k.index(rhs.__adt_ctor_name__) :
         _compare_data(rhs)
     end
 
     def _eq_data(rhs)
-      _data == rhs._data
+      __adt_data__ == rhs.__adt_data__
     end
 
     def _compare_data(rhs)
-      _data.values_at(*ctor_keys) <=> rhs._data.values_at(*ctor_keys)
+      __adt_data__.values_at(*__adt_ctor_keys__) <=>
+        rhs.__adt_data__.values_at(*__adt_ctor_keys__)
     end
 
     # pattern matching
@@ -154,12 +188,13 @@ module Obfusk
         raise ArgumentError,
           "constructors do not match (#{ok} for #{ck})"
       end
-      opts[ctor_name][self]
+      opts[__adt_ctor_name__][self]
     end
 
     # to string
     def to_s
-      "#<#{self.class.superclass.name || '#ADT'}.#{ctor_name}: #{@data}>"
+      n = self.class.superclass.name || '#ADT'
+      "#<#{n}.#{__adt_ctor_name__}: #{__adt_data__}>"
     end
 
     # to string

data/lib/obfusk/atom.rb

@@ -0,0 +1,44 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/atom.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-16
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'thread'
+
+module Obfusk
+  class Atom
+    attr_reader   :value
+    alias :_      :value
+    alias :deref  :value
+
+    # new Atom with value
+    def initialize(value)
+      @mutex = Mutex.new
+      @value = value
+    end
+
+    # calls block with value; uses a mutex to synchronize
+    def with_value(&b)
+      @mutex.synchronize { b[value] }
+    end
+
+    # atomically swaps the value to be `b[oldvalue]`; uses
+    # `with_value`
+    def swap!(&b)
+      with_value { |v| @value = b[v] }
+    end
+  end
+
+  # create an Atom
+  def self.atom(value)
+    Atom.new value
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/lazy.rb

@@ -2,7 +2,7 @@
 #
 # File        : obfusk/lazy.rb
 # Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-# Date        : 2014-06-15
+# Date        : 2014-06-17
 #
 # Copyright   : Copyright (C) 2014  Felix C. Stegerman
 # Licence     : LGPLv3+
@@ -16,7 +16,8 @@ module Obfusk
     f = b ? b : -> { x }; v = nil; e = false
     g = -> () { unless e then v = f[]; e = true end; v }
     g.define_singleton_method(:__obfusk_lazy__?) { true }
-    g.define_singleton_method(:_) { g[] }
+    g.define_singleton_method(:_)     { g[] }
+    g.define_singleton_method(:deref) { g[] }
     g.define_singleton_method(:chain) do |m,*a,&b|
       ::Obfusk::lazy { g[].public_send(m,*a,&b) }
     end

data/lib/obfusk/list.rb

@@ -2,7 +2,7 @@
 #
 # File        : obfusk/list.rb
 # Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-# Date        : 2014-06-15
+# Date        : 2014-06-17
 #
 # Copyright   : Copyright (C) 2014  Felix C. Stegerman
 # Licence     : LGPLv3+
@@ -22,8 +22,10 @@ module Obfusk
 
     constructor :Nil
     constructor(:Cons, :head, :tail) do |cls, data, values, f|
-      v = values.length + (f ? 1 : 0)
-      if (k = cls.ctor_keys.length) != v
+      # count block as extra value; count nil tail as missing one
+      v = values.length + (f ? 1 : 0) -
+          (values.length > 1 && !data[:tail] ? 1 : 0)
+      if (k = cls.__adt_ctor_keys__.length) != v
         raise ArgumentError, "wrong number of arguments (#{v} for #{k})"
       end
       { head: data[:head], tail: f ? ::Obfusk.lazy(&f) :
@@ -81,16 +83,16 @@ module Obfusk
     # the list of those elements that satisfy the predicate
     def filter(p = nil, &b)
       g = p || b
-      match Nil:  -> (_)  { Nil() },
-            Cons: -> (xs) { g[xs.head] ? Cons(xs.head) { xs.tail.filter(g) }
-                                       :                 xs.tail.filter(g) }
+      match Nil:  -> (_) { Nil() },
+            Cons: -> (_) { g[head] ? Cons(head) { tail.filter(g) }
+                                   :              tail.filter(g) }
     end
 
     # the list obtained by applying a function (or block) to each element
     def map(f = nil, &b)
       g = f || b
-      match Nil:  -> (_)  { Nil() },
-            Cons: -> (xs) { Cons(g[xs.head]) { xs.tail.map g } }
+      match Nil:  -> (_) { Nil() },
+            Cons: -> (_) { Cons(g[head]) { tail.map g } }
     end
 
     # --
@@ -123,8 +125,8 @@ module Obfusk
 
     # append two lists
     def append(ys)
-      match Nil:  -> (_)  { ys._ },
-            Cons: -> (xs) { Cons(xs.head) { xs.tail.append ys } }
+      match Nil:  -> (_) { ys._ },
+            Cons: -> (_) { Cons(head) { tail.append ys } }
     end
 
     # def reverse
@@ -146,8 +148,8 @@ module Obfusk
     # operator is lazy and must be treated as such.
     def foldr(z, f = nil, &b)
       g = f || b
-      match Nil:  -> (_)  { z },
-            Cons: -> (xs) { g[xs.head, xs.tail.chain(:foldr, z, g)] }
+      match Nil:  -> (_) { z },
+            Cons: -> (_) { g[head, tail.chain(:foldr, z, g)] }
     end
 
     # def foldr1
@@ -189,8 +191,8 @@ module Obfusk
     # the prefix of length n (or the list itself if n > length)
     def take(n)
       return Nil() if n <= 0
-      match Nil:  -> (_)  { Nil() },
-            Cons: -> (xs) { Cons(xs.head) { xs.tail.take(n - 1) } }
+      match Nil:  -> (_) { Nil() },
+            Cons: -> (_) { Cons(head) { tail.take(n - 1) } }
     end
 
     # def drop
@@ -238,7 +240,7 @@ module Obfusk
     # TODO
     # def self.bind_pass(m, &b)
     #   m.match Nil:  -> (_) { m },
-    #           Cons: -> (x) {}     # concat (map f m)
+    #           Cons: -> (_) {}     # concat (map f m)
     # end
   end
 

data/lib/obfusk/monad.rb

@@ -2,7 +2,7 @@
 #
 # File        : obfusk/monad.rb
 # Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-# Date        : 2014-06-15
+# Date        : 2014-06-16
 #
 # Copyright   : Copyright (C) 2014  Felix C. Stegerman
 # Licence     : LGPLv3+
@@ -40,7 +40,8 @@ module Obfusk
       # bind m, k         # discard value
       # ```
       def bind(m, k = nil, &b)
-        b ? bind_pass(m, &b) : bind_discard(m, k)
+        b ? bind_pass(m, &b) : k.is_a?(::Proc) ? bind_pass(m, &k) :
+                                                 bind_discard(m, k)
       end
 
       # sequentially compose two actions, passing any value produced
@@ -71,7 +72,8 @@ module Obfusk
 
       # concatenate a sequence of binds
       def pipeline(m, *fs)
-        fs.empty? ? m : m.bind { |k| pipeline fs.first[k], *fs.drop(1) }
+        a = -> f, x { f.is_a?(::Proc) ? f[x] : f }
+        fs.empty? ? m : m.bind { |x| pipeline a[fs.first,x], *fs.drop(1) }
       end
 
       # evaluate each action in the sequence from left to right, and
@@ -94,6 +96,10 @@ module Obfusk
         self.class.public_send m, self, *a, &b
       end
     end
+
+    def >>(k)
+      bind k
+    end
   end
 
   module MonadPlus

data/lib/obfusk/monads.rb

@@ -2,7 +2,7 @@
 #
 # File        : obfusk/monads.rb
 # Maintainer  : Felix C. Stegerman <flx@obfusk.net>
-# Date        : 2014-06-15
+# Date        : 2014-06-17
 #
 # Copyright   : Copyright (C) 2014  Felix C. Stegerman
 # Licence     : LGPLv3+
@@ -13,48 +13,140 @@ require 'obfusk/adt'
 require 'obfusk/monad'
 
 module Obfusk
-  class Maybe
-    include ADT
-    include Monad
-    include MonadPlus
+  module Monads
+    class Identity
+      include ADT
+      include Monad
 
-    constructor :Nothing
-    constructor :Just, :value
+      constructor :Identity, :run
 
-    def self.mreturn(x)
-      Just(x)
+      def self.mreturn(x)
+        Identity(x)
+      end
+      def self.bind_pass(m, &b)
+        b[m.run]
+      end
     end
-    def self.bind_pass(m, &b)
-      m.match Nothing:  -> (_) { Nothing()  },
-              Just:     -> (x) { b[x.value] }
-    end
-    def self.zero
-      Nothing()
-    end
-    def self.lazy_plus(m, k)
-      m.match Nothing:  -> (_) { k._ },
-              Just:     -> (_) { m   }
+
+    class Maybe
+      include ADT
+      include Monad
+      include MonadPlus
+
+      constructor :Nothing
+      constructor :Just, :value
+
+      def self.mreturn(x)
+        Just(x)
+      end
+      def self.bind_pass(m, &b)
+        m.match Nothing:  -> (_) { Nothing()  },
+                Just:     -> (x) { b[x.value] }
+      end
+      def self.zero
+        Nothing()
+      end
+      def self.lazy_plus(m, k)
+        m.match Nothing:  -> (_) { k._ },
+                Just:     -> (_) { m   }
+      end
     end
-  end
 
-  class Either
-    include ADT
-    include Monad
+    class Either
+      include ADT
+      include Monad
 
-    constructor :Left , :value
-    constructor :Right, :value
+      constructor :Left , :value
+      constructor :Right, :value
 
-    def self.mreturn(x)
-      Right(x)
+      def self.mreturn(x)
+        Right(x)
+      end
+      def self.bind_pass(m, &b)
+        m.match Left:   -> (_) { m },
+                Right:  -> (x) { b[x.value] }
+      end
     end
-    def self.bind_pass(m, &b)
-      m.match Left:   -> (_) { m },
-              Right:  -> (x) { b[x.value] }
+
+    class State
+      include ADT
+      include Monad
+
+      class Pair
+        include ADT
+        constructor :Pair, :value, :state
+      end
+
+      Pair.import_constructors self, false
+
+      constructor :State, :run
+
+      # construct a state monad computation from a function (or block)
+      def self.state(f = nil, &b)
+        State f || b
+      end
+
+      # evaluate response with the given initial state and return the
+      # final value, discarding the final state
+      def self.eval(m, s)
+        m.run[s].value
+      end
+
+      # evaluate response with the given initial state and return the
+      # final state, discarding the final value
+      def self.exec(m, s)
+        m.run[s].state
+      end
+
+      # execute action on a state modified by applying a function (or
+      # block)
+      def self.with(m, f = nil, &b)
+        state { |s| m.run[(f || b)[s]] }
+      end
+
+      # get the state
+      def self.get
+        state { |s| Pair s, s }
+      end
+
+      # set the state
+      def self.put(s)
+        state { |_| Pair nil, s }
+      end
+
+      # modify the state by applying a function (or block)
+      def self.modify(f = nil, &b)
+        state { |s| Pair nil, (f || b)[s] }
+      end
+
+      # get a specific component of the state, using a projection
+      # function (or block)
+      def self.gets(f = nil, &b)
+        state { |s| Pair (f || b)[s], s }
+      end
+
+      def self.mreturn(x)
+        state { |s| Pair x, s }
+      end
+      def self.bind_pass(m, &b)
+        state { |s| x = m.run[s]; b[x.value].run[x.state] }
+      end
+
+      %w{ eval exec with }.map(&:to_sym).each do |m|
+        define_method(m) do |*a,&b|
+          self.class.public_send m, self, *a, &b
+        end
+      end
     end
-  end
 
-  [Maybe, Either].each { |x| x.import_constructors self }
+    [Maybe, Either].each do |x|
+      x.import_constructors self
+    end
 
+    [Identity, State].each do |x|
+      x.import_constructors self, false
+    end
+  end
 end
 
 # vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/version.rb

@@ -1,4 +1,4 @@
 module Obfusk
-  VERSION = '0.1.1'
-  DATE    = '2014-06-16'
+  VERSION = '0.1.2'
+  DATE    = '2014-06-18'
 end

data/lib/obfusk.rb

@@ -1,4 +1,5 @@
 require 'obfusk/adt'
+require 'obfusk/atom'
 require 'obfusk/lazy'
 require 'obfusk/list'
 require 'obfusk/monad'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: obfusk
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Felix C. Stegerman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-16 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -65,6 +65,7 @@ files:
 - Rakefile
 - lib/obfusk.rb
 - lib/obfusk/adt.rb
+- lib/obfusk/atom.rb
 - lib/obfusk/lazy.rb
 - lib/obfusk/list.rb
 - lib/obfusk/monad.rb