rupture 0.0.0 → 0.1.0

data/README.md

@@ -0,0 +1,17 @@
+It's hard to go back to Ruby once you've gotten used to programming in Clojure. Rupture makes the
+transition easier by giving you the power of Clojure's sequence library and higher order functions
+in Ruby.
+
+## Installation
+
+    gem install rupture
+
+## Usage
+
+    require 'rupture'
+    # see the tests for examples
+
+## Coming soon
+
+* improved README
+* hamster-based persistent data structures

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rake'
 require 'rake/testtask'
-require 'rdoc/task'
+require 'rubygems'
 
 begin
   require 'jeweler'
@@ -14,7 +14,7 @@ begin
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
 end
 
 Rake::TestTask.new do |t|
@@ -23,14 +23,6 @@ Rake::TestTask.new do |t|
   t.verbose = false
 end
 
-Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title    = 'model_set'
-  rdoc.options << '--line-numbers' << '--inline-source'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
-
 begin
   require 'rcov/rcovtask'
   Rcov::RcovTask.new do |t|

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.0

data/init.rb

@@ -0,0 +1 @@
+require 'rupture'

data/lib/rupture/array_seq.rb

@@ -0,0 +1,65 @@
+module Rupture
+  class ArraySeq < Seq
+    def initialize(array, index = 0)
+      @array = array
+      @index = index
+      super()
+    end
+
+    def first
+      @array[@index]
+    end
+
+    def rest
+      ArraySeq.new(@array, @index.inc)
+    end
+
+    def seq
+      self if @index < @array.size
+    end
+
+    def size
+      @array.size - @index
+    end
+  end
+
+  class RArraySeq < ArraySeq
+    def initialize(array, index = array.size - 1)
+      super(array, index)
+    end
+
+    def rest
+      RArraySeq.new(@array, @index.dec)
+    end
+
+    def seq
+      self if @index >= 0
+    end
+
+    def size
+      @index.inc
+    end
+  end
+
+  module ArraySeqable
+    def seq
+      Rupture::ArraySeq.new(self).seq
+    end
+
+    def rseq
+      Rupture::RArraySeq.new(self).seq
+    end
+
+    def not_empty
+      self if seq
+    end
+  end
+end
+
+class Array
+  include Rupture::ArraySeqable
+end
+
+class String
+  include Rupture::ArraySeqable
+end

data/lib/rupture/cons.rb

@@ -0,0 +1,18 @@
+module Rupture
+  class Cons < Seq
+    attr_reader :first
+
+    def initialize(first, rest)
+      @first, @rest = first, rest
+      super()
+    end
+
+    def seq
+      self
+    end
+
+    def rest
+      @rest ||= Seq.empty
+    end
+  end
+end

data/lib/rupture/core_ext.rb

@@ -0,0 +1,21 @@
+class Numeric
+  def inc
+    self + 1
+  end
+
+  def dec
+    self - 1
+  end
+
+  def pos?
+    self > 0
+  end
+
+  def neg?
+    self < 0
+  end
+
+  def zero?
+    self == 0
+  end
+end

data/lib/rupture/fn.rb

@@ -0,0 +1,88 @@
+require 'set'
+
+module Rupture
+  module Fn
+    def complement
+      lambda do |*args|
+        not call(*args)
+      end
+    end
+    alias -@ complement
+
+    def comp(fn)
+      lambda do |*args|
+        call(fn[*args])
+      end
+    end
+    alias * comp
+
+    def partial(*partials)
+      lambda do |*args|
+        call(*(partials + args))
+      end
+    end
+
+    # def apply(*args)
+    #   last = args.pop
+    #   call(*F.concat(args, last))
+    # end
+
+    def to_proc
+      lambda do |key|
+        self[key]
+      end
+    end
+
+    def arity
+      -1
+    end
+  end
+end
+
+class Proc
+  include Rupture::Fn
+end
+
+class Method
+  include Rupture::Fn
+end
+
+class Symbol
+  include Rupture::Fn
+
+  def call(object = nil, *args)
+    object.method(self)[*args]
+  end
+  alias [] call
+
+  def arity
+    -2
+  end
+end
+
+class Hash
+  include Rupture::Fn
+  alias call []
+end
+
+class Array
+  include Rupture::Fn
+  alias call []
+end
+
+class Set
+  include Rupture::Fn
+
+  def [](key)
+    key if include?(key)
+  end
+  alias call []
+end
+
+class Module
+  def [](method_name, *partials)
+    lambda do |*args|
+      self.send(method_name, *(args + partials))
+    end
+  end
+end

data/lib/rupture/function.rb

@@ -0,0 +1,114 @@
+module Rupture
+  module Function
+    # FIXME isn't totally lazy when working with > 1 collection
+    # If the first is empty, the second is still seq'd
+    def map(*colls, &f)
+      f ||= colls.shift
+      lazy_seq do
+        seqs = colls.collect(&:seq)
+        if seqs.all?
+          firsts = seqs.collect(&:first)
+          rests  = seqs.collect(&:rest)
+          cons(f[*firsts], map(*rests, &f))
+        end
+      end
+    end
+
+    def concat(*colls)
+      lazy_seq do
+        head, *tail = colls.collect(&:seq)
+        if head
+          cons(head.first, concat(head.rest, *tail))
+        elsif tail.any?
+          concat(*tail)
+        end
+      end
+    end
+
+    def mapcat(*colls, &f)
+      f ||= colls.shift
+      concat(*map(*colls, &f))
+    end
+
+    def zip(*colls)
+      lazy_seq do
+        seqs = colls.collect(&:seq)
+        if seqs.any?
+          firsts = seqs.collect(&:first)
+          rests  = seqs.collect(&:rest)
+          cons(firsts, zip(*rests))
+        end
+      end
+    end
+
+    def loop(*vals)
+      more  = true
+      recur = lambda {|*vals| more = true}
+
+      while more
+        more = nil
+        result = yield(recur, *vals)
+      end
+      result
+    end
+
+    def iterate(*args, &f)
+      f ||= args.shift
+      Utils.verify_args(args, 1)
+      x = args.first
+      lazy_seq do
+        cons(x, iterate(f[x], &f))
+      end
+    end
+
+    def repeatedly(*args, &fn)
+      fn ||= args.pop
+      Utils.verify_args(args, 0, 1)
+      n = args.first
+
+      lazy_seq do
+        if n.nil?
+          cons(fn[], repeatedly(n, fn))
+        elsif n > 0
+          cons(fn[], repeatedly(n.dec, fn))
+        end
+      end
+    end
+
+    def repeat(*args)
+      Utils.verify_args(args, 1, 2)
+      x, n = args.reverse
+      repeatedly(n) {x}
+    end
+
+    def lazy_seq(f = nil, &fn)
+      fn ||= f
+      LazySeq.new(&fn)
+    end
+
+    def cons(head, tail)
+      Cons.new(head, tail)
+    end
+
+    def list(*xs)
+      List.new(*xs)
+    end
+
+    def identity(x)
+      x
+    end
+
+    def juxt(*fs)
+      lambda do |*args|
+        fs.collect {|f| f[*args]}
+      end
+    end
+
+    def decorate(*args)
+      juxt(identity, *args)
+    end
+
+    extend Function
+    F = Function
+  end
+end

data/lib/rupture/lazy_seq.rb

@@ -0,0 +1,35 @@
+module Rupture
+  class LazySeq < Seq
+    def initialize(b = nil, &block)
+      @block = block || b
+      super()
+    end
+
+    def seq
+      return @seq unless @block
+      @seq   = @block.call.seq
+      @block = nil
+      @seq
+    end
+  end
+end
+
+module Enumerable
+  def seq
+    F.lazy_seq do
+      callcc do |external|
+        each do |item|
+          external = callcc do |internal|
+            rest = F.lazy_seq do
+              callcc do |external|
+                internal.call(external)
+              end
+            end
+            external.call(F.cons(item, rest))
+          end
+        end
+        external.call(nil)
+      end
+    end
+  end
+end

data/lib/rupture/list.rb

@@ -0,0 +1,31 @@
+module Rupture
+  class List < Seq
+    class << self
+      alias create new
+    end
+    private_class_method :create
+    attr_reader :seq, :size
+
+    def self.empty
+      @empty ||= create(nil, 0)
+    end
+
+    def initialize(seq, size)
+      @seq = seq.seq
+      @size = size
+    end
+
+    def self.new(*args)
+      list = self.empty
+      args.reverse_each do |x|
+        list = list.conj(x)
+      end
+
+      list
+    end
+
+    def conj(x)
+      self.class.send(:create, Cons.new(x, @seq), @size.inc)
+    end
+  end
+end

data/lib/rupture/lookup.rb

@@ -0,0 +1,24 @@
+module Rupture
+  module Lookup
+    def lookup
+      lambda do |a|
+        a[self]
+      end
+    end
+  end
+end
+
+class Symbol
+  include Rupture::Lookup
+
+  alias ~ lookup
+end
+
+class String
+  include Rupture::Lookup
+end
+
+class Numeric
+  include Rupture::Lookup
+end
+

data/lib/rupture/meta.rb

@@ -0,0 +1,22 @@
+module Rupture::Meta
+  def meta
+    @_meta ||= {}
+  end
+
+  def clone(meta = nil)
+    meta ||= @_meta.clone if @_meta
+    raise "meta must be of type Hash, it is #{meta.class}" unless meta.nil? or meta.kind_of?(Hash)
+    copy = super()
+    copy.instance_variable_set(:@_meta, meta)
+    copy
+  end
+
+  def with_meta(meta)
+    clone(meta)
+  end
+
+  def vary_meta(*args, &fn)
+    fn ||= args.shift
+    with_meta(fn[meta, *args])
+  end
+end

data/lib/rupture/rails_ext.rb

@@ -0,0 +1,38 @@
+class Hash
+  def symbolize_keys!
+    keys.each do |key|
+      self[(key.to_sym rescue key) || key] = delete(key)
+    end
+    self
+  end
+
+  def symbolize_keys
+    dup.symbolize_keys!
+  end
+
+  def deep_symbolize_keys!
+    values.each do |val|
+      val.deep_symbolize_keys! if val.is_a?(Hash)
+    end
+    symbolize_keys!
+  end
+
+  def deep_symbolize_keys
+    copy = symbolize_keys
+    copy.each do |key, val|
+      copy[key] = val.deep_symbolize_keys if val.is_a?(Hash)
+    end
+    copy
+  end
+
+  def stringify_keys!
+    keys.each do |key|
+      self[key.to_s] = delete(key)
+    end
+    self
+  end
+
+  def stringify_keys
+    dup.stringify_keys!
+  end
+end

data/lib/rupture/reader.rb

@@ -0,0 +1,110 @@
+require 'set'
+
+module Rupture
+  class Reader
+    def initialize(input)
+      @input  = input
+      @buffer = []
+    end
+
+    def ungetc(*chars)
+      @buffer.concat(chars)
+      @space = false
+      chars.last
+    end
+
+    def getc
+      while c = (@buffer.shift || @input.getc.chr)
+        if c =~ /[\s,;]/
+          next if @space
+          @space = true
+          @input.gets if c == ';'
+          return ' '
+        else
+          @space = false
+          return c
+        end
+      end
+    end
+
+    def peekc
+      unget(getc)
+    end
+
+    def read
+      case c = getc
+      when '('  : read_list
+      when '['  : read_list(Array, ']')
+      when '{'  : read_map
+      when '"'  : read_string
+      when ':'  : read_keyword
+      when ' '  : read
+      when /\d/ : ungetc(c); read_number
+      when /\w/ : ungetc(c); read_symbol
+      when '-'
+        case c = getc
+        when /\d/ : ungetc(c);     -read_number
+        else        ungetc('-', c); read_symbol
+        end
+      when '#'
+        case c = getc
+        when '{' : read_list(Set, '}')
+        end
+      end
+    end
+
+    def read_list(klass = List, terminator = ')')
+      list = klass.new
+      while c = getc
+        return list if c == terminator
+        ungetc(c)
+        list << read
+      end
+    end
+
+    def read_map
+      map = {}
+      while c = getc
+        return map if c == '}'
+        ungetc(c)
+        list[read] = read
+      end
+    end
+
+    def read_string
+      string = ''
+      while c = getc
+        return string if c == '"'
+        string << c
+      end
+    end
+
+    def read_while(pattern, token = '')
+      while c = getc
+        if c !~ pattern
+          ungetc(c)
+          return token
+        end
+        token << c
+      end
+    end
+
+    def read_symbol(prefix = '@')
+      read_while(/[^\s{}\[\]()]/, prefix).to_sym
+    end
+
+    def read_keyword
+      read_symbol('')
+    end
+
+    def read_number
+      number = read_while(/[-\d]/)
+      if (c = getc) == '.'
+        read_while(/\d/, number << '.').to_f
+      else
+        ungetc(c)
+        number.to_i
+      end
+    end
+  end
+end

data/lib/rupture/seq.rb

@@ -0,0 +1,62 @@
+module Rupture
+  class Seq < Enumerable::Enumerator
+    include Sequence
+
+    def initialize
+      super(self)
+    end
+
+    def each
+      s = self
+      while s = s.seq
+        yield s.first
+        s = s.rest
+      end
+    end
+
+    def [](index)
+      nth(index)
+    end
+
+    def to_ary
+      to_a
+    end
+
+    def ==(other)
+      s = self.seq
+      o = other.seq
+      while s && o
+        return false if s.first != o.first
+        s = s.next
+        o = o.next
+      end
+      s.nil? and o.nil?
+    end
+
+    def self.empty
+      @empty ||= EmptySeq.new
+    end
+  end
+
+  class EmptySeq < Seq
+    def seq
+      nil
+    end
+  end
+end
+
+class NilClass
+  include Rupture::Sequence
+
+  def seq
+    nil
+  end
+
+  def first
+    nil
+  end
+
+  def rest
+    Rupture::Seq.empty
+  end
+end