obfusk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b19543e886d856d83dffbbf56a1d56a906d12afa
+  data.tar.gz: b00658481e756a75ec2aa009871fab55aac0c6fd
+SHA512:
+  metadata.gz: 44b10eb7fede5ebbadeba7f508b93a24ed01740dadbd2d81a353960859f1f7b4f8ec2928f319e18567ac3a8fec4220f4e9e8e5729359be5437d9250952e86a5e
+  data.tar.gz: 139559e07e39770ca5d89da192acfd843723b1789f2bbf01e054361a31df3a773b0ed0f2a4acbb8b4eb4a4ea7e3296edd8863633b814715cd839ab0289a3b142

data/.yardopts

@@ -0,0 +1 @@
+--markup markdown

data/README.md

@@ -0,0 +1,123 @@
+[]: {{{1
+
+    File        : README.md
+    Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+    Date        : 2014-06-16
+
+    Copyright   : Copyright (C) 2014  Felix C. Stegerman
+    Version     : v0.1.0
+
+[]: }}}1
+
+[![Gem Version](https://badge.fury.io/rb/obfusk.png)](https://badge.fury.io/rb/obfusk)
+
+## Description
+
+  obfusk.rb - functional programming library for ruby
+
+## Examples
+[]: {{{1
+
+```ruby
+require 'obfusk/adt'
+
+class Foo
+  include Obfusk::ADT
+  constructor :Bar
+  constructor :Baz, :value
+end
+
+x = Foo.Bar()
+y = Foo.Baz 99
+
+puts y.value # => 99
+```
+
+```ruby
+require 'obfusk/lazy'
+
+x = Obfusk.lazy { some_expensive_computation_that_returns_42 }
+x._ # => 42 (expensive computation not run until now)
+x._ # => 42 (cached)
+
+y = Obfusk.lazy { Foo.new 42 }
+z = y.chain(:value)
+z._ # => 42 (.new and .value not run until now)
+
+Obfusk.eager(lazy_or_not) # => value
+```
+
+```ruby
+require 'obfusk/list'
+
+fibs = Obfusk.List(0,1) { fibs.zipWith(fibs.tail, &:+) }
+
+fibs == Obfusk.Nil
+# => false
+
+fibs.take(10).to_a
+# => [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
+
+fibs.map { |x| x*x } .take(10).to_a
+# => [0, 1, 1, 4, 9, 25, 64, 169, 441, 1156]
+```
+
+```ruby
+require 'obfusk/monad'
+
+class Foo
+  include Obfusk::Monad
+  def self.return(x)
+    # ...
+  end
+  def self.bind_pass(m, &b)
+    # ...
+  end
+end
+
+f = -> x { '...' }
+g = -> y { '...' }
+
+Foo.pipeline Foo.new('...'), f, g
+```
+
+```ruby
+require 'obfusk/monads'
+
+x = Obfusk.Nothing
+y = Obfusk.Just 42
+
+x.bind(y)
+# => Obfusk.Nothing
+
+Obfusk.Left "oops"
+Obfusk.Right 37
+```
+
+...
+
+[]: }}}1
+
+## Specs & Docs
+
+```bash
+$ rake spec
+$ rake docs
+```
+
+## TODO
+
+  * more lists operations
+  * more stuff from obfusk.coffee
+  * ...
+
+## License
+
+  LGPLv3+ [1].
+
+## References
+
+  [1] GNU Lesser General Public License, version 3
+  --- http://www.gnu.org/licenses/lgpl-3.0.html
+
+[]: ! ( vim: set tw=70 sw=2 sts=2 et fdm=marker : )

data/Rakefile

@@ -0,0 +1,58 @@
+desc 'Run specs'
+task :spec do
+  sh 'rspec -c'
+end
+
+desc 'Run specs verbosely'
+task 'spec:verbose' do
+  sh 'rspec -cfd'
+end
+
+desc 'Run specs verbosely, view w/ less'
+task 'spec:less' do
+  sh 'rspec -cfd --tty | less -R'
+end
+
+desc 'Check for warnings'
+task :warn do
+  sh 'ruby -w -I lib -r obfusk -e ""'   # TODO
+end
+
+desc 'Check for warnings in specs'
+task 'warn:spec' do
+  reqs = Dir['spec/**/*.rb'].sort.map { |x| "-r ./#{x}" } * ' '
+  sh "ruby -w -I lib -r rspec #{reqs} -e ''"
+end
+
+desc 'Check for warnings in specs (but not void context)'
+task 'warn:spec:novoid' do
+  sh 'rake warn:spec 2>&1 | grep -v "void context"'
+end
+
+desc 'Generate docs'
+task :docs do
+  sh 'yardoc | cat'
+end
+
+desc 'List undocumented objects'
+task 'docs:undoc' do
+  sh 'yard stats --list-undoc'
+end
+
+desc 'Cleanup'
+task :clean do
+  sh 'rm -rf .yardoc/ doc/ *.gem'
+end
+
+desc 'Build SNAPSHOT gem'
+task :snapshot do
+  v = Time.new.strftime '%Y%m%d%H%M%S'
+  f = 'lib/obfusk/version.rb'
+  sh "sed -ri~ 's!(SNAPSHOT)!\\1.#{v}!' #{f}"
+  sh 'gem build obfusk.gemspec'
+end
+
+desc 'Undo SNAPSHOT gem'
+task 'snapshot:undo' do
+  sh 'git checkout -- lib/obfusk/version.rb'
+end

data/lib/obfusk/adt.rb

@@ -0,0 +1,172 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/adt.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-15
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'thread'
+
+module Obfusk
+
+  ADT_Meta__ = { inheriting: [false], mutex: Mutex.new }
+
+  # Algebraic Data Type
+  module ADT
+    include Comparable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    # use a contructor!
+    # @raise NoMethodError
+    def initialize
+      raise NoMethodError, 'use a contructor!'  # TODO
+    end
+
+    module ClassMethods
+      # 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]
+          end
+        end
+      end
+
+      # create a constructor
+      # @param [Symbol]   name  the name of the constructor
+      # @param [<Symbol>] keys  the keys of the constructor
+      def constructor(name, *keys, &b)
+        keys_ = keys.map(&:to_sym)
+        name_ = name.to_sym
+        ctor  = ::Obfusk::ADT_Meta__[:mutex].synchronize do
+          begin
+            ::Obfusk::ADT_Meta__[:inheriting] << true
+            Class.new self
+          ensure
+            ::Obfusk::ADT_Meta__[:inheriting].pop
+          end
+        end
+        ctor.class_eval do
+          attr_accessor :ctor, :ctor_name, :ctor_keys
+          keys_.each { |k| define_method(k) { @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]
+            @ctor = ctor ; @ctor_name = name_ ; @ctor_keys = keys_
+            @data = b ? b[self, data, values, f] : data
+          end
+        end
+        class_eval do
+          const_set name_, ctor
+          f = -> v, b { ctor.new :for_internal_use_only, ctor, *v, &b }
+          if !b && keys.empty?
+            singleton = f[[],nil]
+            define_singleton_method(name_) { singleton }
+            define_method(name_)           { singleton }
+          else
+            define_singleton_method(name_) { |*values,&b| f[values,b] }
+            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
+          }
+        end
+        name_
+      end
+      private :constructor
+
+      # the constructors
+      def constructors
+        @constructors ||= {}
+      end
+
+      # import the constructors into another namespace
+      def import_constructors(scope)
+        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]
+        end
+      end
+
+      # pattern matching
+      def match(x, opts)
+        raise ArgumentError, 'not an ADT' unless x.is_a?(::Obfusk::ADT)
+        raise ArgumentError,
+          "types do not match (#{x.class.superclass} for #{self})" \
+            unless x.class.superclass == self
+        x.match opts
+      end
+    end
+
+    # the data
+    def _data
+      @data
+    end
+
+    # equal?
+    def ==(rhs)
+      rhs.is_a?(::Obfusk::ADT) &&
+        self.class.superclass == rhs.class.superclass &&
+        ctor == rhs.ctor && _eq_data(rhs)
+    end
+
+    # equal and of the same type?
+    def eql?(rhs)
+      self == rhs
+    end
+
+    # ordering
+    def <=>(rhs)
+      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) :
+        _compare_data(rhs)
+    end
+
+    def _eq_data(rhs)
+      _data == rhs._data
+    end
+
+    def _compare_data(rhs)
+      _data.values_at(*ctor_keys) <=> rhs._data.values_at(*ctor_keys)
+    end
+
+    # pattern matching
+    def match(opts)
+      unless (ck = self.class.superclass.constructors.keys.sort) ==
+             (ok = opts.keys.sort)
+        raise ArgumentError,
+          "constructors do not match (#{ok} for #{ck})"
+      end
+      opts[ctor_name][self]
+    end
+
+    # to string
+    def to_s
+      "#<#{self.class.superclass.name || '#ADT'}.#{ctor_name}: #{@data}>"
+    end
+
+    # to string
+    def inspect
+      to_s
+    end
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/lazy.rb

@@ -0,0 +1,37 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/lazy.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-15
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+module Obfusk
+  # lazy evaluation (thunk)
+  def self.lazy(x = nil, &b)
+    return x if lazy? x
+    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(:chain) do |m,*a,&b|
+      ::Obfusk::lazy { g[].public_send(m,*a,&b) }
+    end
+    g
+  end
+
+  # lazy?
+  def self.lazy?(x)
+    x.respond_to?(:__obfusk_lazy__?) && x.__obfusk_lazy__?
+  end
+
+  # eager: evaluate if lazy, just return if not
+  def self.eager(x)
+    lazy?(x) ? x._ : x
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/list.rb

@@ -0,0 +1,256 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/list.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-15
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'obfusk/adt'
+require 'obfusk/lazy'
+require 'obfusk/monad'
+
+module Obfusk
+  # Lazy List
+  class List
+    include ADT
+    include Monad
+    include MonadPlus
+
+    constructor :Nil
+    constructor(:Cons, :head, :tail) do |cls, data, values, f|
+      v = values.length + (f ? 1 : 0)
+      if (k = cls.ctor_keys.length) != v
+        raise ArgumentError, "wrong number of arguments (#{v} for #{k})"
+      end
+      { head: data[:head], tail: f ? ::Obfusk.lazy(&f) :
+                                     ::Obfusk.lazy(data[:tail]) }
+    end
+
+    class Cons
+      # lazy tail
+      alias :lazy_tail :tail
+
+      # eager tail
+      def tail
+        lazy_tail._
+      end
+    end
+
+    def _eq_data(rhs)
+       match  Nil:  -> (_) { true },
+              Cons: -> (_) { [head,tail] == [rhs.head,rhs.tail] }
+    end
+
+    def _compare_data(rhs)
+       match  Nil:  -> (_) { 0 },
+              Cons: -> (_) { [head,tail] <=> [rhs.head,rhs.tail] }
+    end
+
+    # --
+
+    def each(&b)
+      return enum_for :each unless b
+      xs = self; while xs != Nil() do b[xs.head]; xs = xs.tail end
+    end
+
+    def to_s
+      *xs, x = self.class.name.split '::'; n = xs*'::' + '.' + x
+      self == Nil() ? "<##{n}>" : "<##{n}(#{head},...)>"
+    end
+
+    def to_a
+      each.to_a
+    end
+
+    # pretend to be lazy (so we don't need Obfusk.eager)
+    def _
+      self
+    end
+
+    # pretend to be lazy (see _)
+    def chain(m,*a,&b)
+      ::Obfusk.lazy { public_send(m,*a,&b) }
+    end
+
+    # --
+
+    # 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) }
+    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 } }
+    end
+
+    # --
+
+    # element at index
+    def [](i)
+      raise ArgumentError, 'negative index' if i < 0
+      j = 0; each { |x| return x if i == j; j += 1 }
+      raise ArgumentError, 'index too large'
+    end
+
+    # length
+    def length
+      n = 0; each { n += 1 }; n
+    end
+
+    # empty?
+    def null
+      match Nil: -> (_) { true }, Cons: -> (_) { false }
+    end
+    alias :null?  :null
+    alias :empty? :null
+
+    # --
+
+    # def last
+    # def init
+
+    # --
+
+    # append two lists
+    def append(ys)
+      match Nil:  -> (_)  { ys._ },
+            Cons: -> (xs) { Cons(xs.head) { xs.tail.append ys } }
+    end
+
+    # def reverse
+
+    # -- Reducing lists (folds) --
+
+    # def foldl
+    # def foldl1
+
+    # foldr, applied to a binary operator, a starting value (typically
+    # the right-identity of the operator), and a list, reduces the
+    # list using the binary operator, from right to left:
+    #
+    # ```haskell
+    # foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
+    # ```
+    #
+    # NB: because ruby is not lazy, the secons argument of the binary
+    # 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)] }
+    end
+
+    # def foldr1
+
+    # -- Special folds --
+
+    # def and
+    # def or
+    # def any
+
+    # concatenate a list of lists
+    def concat
+      foldr(Nil()) { |x,ys| x.append ys }
+    end
+
+    # def concatMap
+
+    # def sum
+    # def product
+    # def maximum
+    # def minimum
+
+    # -- Building lists --
+
+    # def scanl
+    # def scanl1
+    # def scanr
+    # def scanr1
+
+    # -- Infinite lists --
+
+    # def iterate
+    # def repeat
+    # def replicate
+    # def cycle
+
+    # -- Sublists --
+
+    # 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) } }
+    end
+
+    # def drop
+    # def splitAt
+    # def takeWhile
+    # def dropWhile
+    # def span
+    # def break
+
+    # -- Searching lists --
+
+    # def elem
+    # def notElem
+    # def lookup
+
+    # -- Zipping and unzipping lists --
+
+    # def zip
+    # def zip3
+
+    # combine parallel elements of two lists using a binary operator
+    def zipWith(ys, f = nil, &b)
+      g = f || b
+      self == Nil() || ys._ == Nil() ? Nil() :
+        Cons(g[head, ys._.head]) { tail.zipWith(ys._.tail, g) }
+    end
+
+    # def zipWith3
+    # def unzip
+    # def unzip3
+
+    # -- Functions on strings --
+
+    # def lines
+    # def words
+    # def unlines
+    # def unwords
+
+    # -- Monad --
+
+    def self.mreturn(x)
+      Cons x, Nil()
+    end
+
+    # TODO
+    # def self.bind_pass(m, &b)
+    #   m.match Nil:  -> (_) { m },
+    #           Cons: -> (x) {}     # concat (map f m)
+    # end
+  end
+
+  List.import_constructors self
+
+  # create a list from its items; pass a block to add a lazy tail
+  def self.List(*xs, &b)
+    b && xs.length == 1 ? Cons(xs.first, &b)  :
+    b && xs.empty?      ? b._                 :
+    xs.empty?           ? Nil()               :
+    Cons(xs.first) { List(*xs.drop(1), &b) }
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/monad.rb

@@ -0,0 +1,126 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/monad.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-15
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'obfusk/lazy'
+
+module Obfusk
+  module Monad
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # inject a value into the monadic type
+      #
+      # implement me!
+      def mreturn(x)
+        raise NotImplementedError
+      end
+
+      # alias for mreturn
+      def return(x)
+        mreturn x
+      end
+
+      # sequentially compose two actions; passing any value produced
+      # by the first as an argument to the second when a block is
+      # used; discarding any value produced by the first when no block
+      # is used; see bind_pass, bind_discard
+      #
+      # ```
+      # bind(m) { |x| k } # pass value
+      # bind m, k         # discard value
+      # ```
+      def bind(m, k = nil, &b)
+        b ? bind_pass(m, &b) : bind_discard(m, k)
+      end
+
+      # sequentially compose two actions, passing any value produced
+      # by the first as an argument to the second
+      #
+      # implement me!
+      def bind_pass(m, &b)
+        raise NotImplementedError
+      end
+
+      # sequentially compose two actions, discarding any value
+      # produced by the first
+      #
+      # implement me!
+      def bind_discard(m, k)
+        bind_pass(m) { |_| k }
+      end
+
+      # map monad (i.e. functor)
+      def fmap(m, f = nil, &b)
+        g = f || b; bind(m) { |k| mreturn g[k] }
+      end
+
+      # flatten monad
+      def join(m)
+        bind(m) { |k| k }
+      end
+
+      # concatenate a sequence of binds
+      def pipeline(m, *fs)
+        fs.empty? ? m : m.bind { |k| pipeline fs.first[k], *fs.drop(1) }
+      end
+
+      # evaluate each action in the sequence from left to right, and
+      # collect the results
+      def sequence(*ms)
+        ms.inject(mreturn []) do |m,k|
+          bind(m) { |xs| bind(k) { |x| mreturn xs+[x] } }
+        end
+      end
+
+      # evaluate each action in the sequence from left to right, and
+      # ignore the results
+      def sequence_(*ms)
+        (ms + [mreturn(nil)]).inject { |m,k| bind(m, k) }
+      end
+    end
+
+    %w{ bind fmap join pipeline sequence sequence_ }.map(&:to_sym).each do |m|
+      define_method(m) do |*a,&b|
+        self.class.public_send m, self, *a, &b
+      end
+    end
+  end
+
+  module MonadPlus
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # identity
+      def zero
+        raise NotImplementedError
+      end
+
+      # associative operation
+      def plus(m, k = nil, &b)
+        lazy_plus m, ::Obfusk.lazy(k, &b)
+      end
+
+      def lazy_plus(m, k)
+        raise NotImplementedError
+      end
+    end
+
+    def plus(k = nil, &b)
+      self.class.plus self, k, &b
+    end
+  end
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/monads.rb

@@ -0,0 +1,60 @@
+# --                                                            ; {{{1
+#
+# File        : obfusk/monads.rb
+# Maintainer  : Felix C. Stegerman <flx@obfusk.net>
+# Date        : 2014-06-15
+#
+# Copyright   : Copyright (C) 2014  Felix C. Stegerman
+# Licence     : LGPLv3+
+#
+# --                                                            ; }}}1
+
+require 'obfusk/adt'
+require 'obfusk/monad'
+
+module Obfusk
+  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
+
+  class Either
+    include ADT
+    include Monad
+
+    constructor :Left , :value
+    constructor :Right, :value
+
+    def self.mreturn(x)
+      Right(x)
+    end
+    def self.bind_pass(m, &b)
+      m.match Left:   -> (_) { m },
+              Right:  -> (x) { b[x.value] }
+    end
+  end
+
+  [Maybe, Either].each { |x| x.import_constructors self }
+
+end
+
+# vim: set tw=70 sw=2 sts=2 et fdm=marker :

data/lib/obfusk/version.rb

@@ -0,0 +1,4 @@
+module Obfusk
+  VERSION = '0.1.0'
+  DATE    = '2014-06-16'
+end

data/lib/obfusk.rb

@@ -0,0 +1,6 @@
+require 'obfusk/adt'
+require 'obfusk/lazy'
+require 'obfusk/list'
+require 'obfusk/monad'
+require 'obfusk/monads'
+require 'obfusk/version'

data/obfusk.gemspec

@@ -0,0 +1,28 @@
+require File.expand_path('../lib/obfusk/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = 'obfusk'
+  s.homepage    = 'https://github.com/obfusk/obfusk.rb'
+  s.summary     = 'functional programming library for ruby'
+
+  s.description = <<-END.gsub(/^ {4}/, '')
+    ...
+  END
+
+  s.version     = Obfusk::VERSION
+  s.date        = Obfusk::DATE
+
+  s.authors     = [ 'Felix C. Stegerman' ]
+  s.email       = %w{ flx@obfusk.net }
+
+  s.licenses    = %w{ LGPLv3+ }
+
+  s.files       = %w{ .yardopts README.md Rakefile obfusk.gemspec } \
+                + Dir['lib/**/*.rb']
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'yard'
+
+  s.required_ruby_version = '>= 1.9.1'
+end

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: obfusk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Felix C. Stegerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-16 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'
+- !ruby/object:Gem::Dependency
+  name: yard
+  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: |
+  ...
+email:
+- flx@obfusk.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- README.md
+- Rakefile
+- lib/obfusk.rb
+- lib/obfusk/adt.rb
+- lib/obfusk/lazy.rb
+- lib/obfusk/list.rb
+- lib/obfusk/monad.rb
+- lib/obfusk/monads.rb
+- lib/obfusk/version.rb
+- obfusk.gemspec
+homepage: https://github.com/obfusk/obfusk.rb
+licenses:
+- LGPLv3+
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.1
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: functional programming library for ruby
+test_files: []
+has_rdoc: