rupture 0.1.0 → 0.2.0

data/.gitignore

@@ -0,0 +1,3 @@
+*~
+Gemfile.lock
+pkg/

data/.rbenv-version

@@ -0,0 +1 @@
+ree-1.8.7-2012.02

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://www.rubygems.org"
+
+gemspec

data/README.md

@@ -14,4 +14,7 @@ in Ruby.
 ## Coming soon
 
 * improved README
-* hamster-based persistent data structures
+* Hash Array Mapped Tries
+* Bitmapped Array Tries
+* Native Implementations
+* Chunked seqs

data/Rakefile

@@ -1,36 +1,10 @@
-require 'rake'
 require 'rake/testtask'
-require 'rubygems'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "rupture"
-    s.summary = %Q{Clojure sequence functions for Ruby.}
-    s.email = "code@justinbalthrop.com"
-    s.homepage = "http://github.com/flatland/rupture"
-    s.description = "Clojure sequence functions for Ruby."
-    s.authors = ["Justin Balthrop"]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler"
-end
+require 'bundler/gem_tasks'
 
 Rake::TestTask.new do |t|
-  t.libs << 'lib'
+  t.libs = ['lib']
   t.pattern = 'test/**/*_test.rb'
   t.verbose = false
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << 'test'
-    t.test_files = FileList['test/**/*_test.rb']
-    t.verbose = true
-  end
-rescue LoadError
-end
-
 task :default => :test

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/rupture/array_seq.rb

@@ -3,7 +3,6 @@ module Rupture
     def initialize(array, index = 0)
       @array = array
       @index = index
-      super()
     end
 
     def first

data/lib/rupture/cons.rb

@@ -12,7 +12,7 @@ module Rupture
     end
 
     def rest
-      @rest ||= Seq.empty
+      @rest ||= Seq::Empty
     end
   end
 end

data/lib/rupture/core_ext.rb

@@ -19,3 +19,17 @@ class Numeric
     self == 0
   end
 end
+
+class Object
+  def map?
+    false
+  end
+
+  def let(*vals)
+    yield(self, *vals)
+  end
+
+  def fix(pred, f = nil, &fn)
+    Rupture::Function.fix(self, pred, fn || f)
+  end
+end

data/lib/rupture/fn.rb

@@ -17,8 +17,28 @@ module Rupture
     alias * comp
 
     def partial(*partials)
+      lambda do |*args, &block|
+        call(*(partials + args), &block)
+      end
+    end
+
+    def rpartial(*partials)
+      lambda do |*args, &block|
+        call(*(args + partials), &block)
+      end
+    end
+
+    def <<(partials)
+      partial(*partials)
+    end
+
+    def >>(partials)
+      rpartial(*partials)
+    end
+
+    def block(&block)
       lambda do |*args|
-        call(*(partials + args))
+        call(*args, &block)
       end
     end
 
@@ -27,9 +47,15 @@ module Rupture
     #   call(*F.concat(args, last))
     # end
 
+    def fnil(*defaults)
+      lambda do |*args|
+        call(*F.map(args, defaults) {|a,d| a.nil? ? d : a})
+      end
+    end
+
     def to_proc
       lambda do |key|
-        self[key]
+        call(key)
       end
     end
 
@@ -50,8 +76,8 @@ end
 class Symbol
   include Rupture::Fn
 
-  def call(object = nil, *args)
-    object.method(self)[*args]
+  def call(object, *args, &block)
+    object.method(self).call(*args, &block)
   end
   alias [] call
 
@@ -82,7 +108,7 @@ end
 class Module
   def [](method_name, *partials)
     lambda do |*args|
-      self.send(method_name, *(args + partials))
+      self.send(method_name, *(partials + args))
     end
   end
 end

data/lib/rupture/function.rb

@@ -1,15 +1,12 @@
 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))
+    def map(*colls, &fn)
+      fn ||= colls.shift
+      lazy_loop(colls.seq.map(:seq)) do |recur, seqs|
+        if seqs.every?
+          firsts = seqs.map(:first)
+          nexts  = seqs.map(:next)
+          cons(fn[*firsts], recur[nexts])
         end
       end
     end
@@ -25,9 +22,9 @@ module Rupture
       end
     end
 
-    def mapcat(*colls, &f)
-      f ||= colls.shift
-      concat(*map(*colls, &f))
+    def mapcat(*colls, &fn)
+      fn ||= colls.shift
+      concat(*map(*colls, &fn))
     end
 
     def zip(*colls)
@@ -41,6 +38,20 @@ module Rupture
       end
     end
 
+    def filter(pred, coll)
+      lazy_seq do
+        if s = coll.seq
+          e = s.first
+          tail = filter(pred, s.rest)
+          pred[e] ? cons(e, tail) : tail
+        end
+      end
+    end
+
+    def remove(pred, coll)
+      filter(pred.complement, coll)
+    end
+
     def loop(*vals)
       more  = true
       recur = lambda {|*vals| more = true}
@@ -52,12 +63,19 @@ module Rupture
       result
     end
 
-    def iterate(*args, &f)
-      f ||= args.shift
+    def lazy_loop(*vals, &block)
+      recur = lambda do |*v|
+        lazy_seq {block[recur, *v]}
+      end
+      recur[*vals]
+    end
+
+    def iterate(*args, &fn)
+      fn ||= args.shift
       Utils.verify_args(args, 1)
       x = args.first
       lazy_seq do
-        cons(x, iterate(f[x], &f))
+        cons(x, iterate(fn[x], &fn))
       end
     end
 
@@ -83,7 +101,7 @@ module Rupture
 
     def lazy_seq(f = nil, &fn)
       fn ||= f
-      LazySeq.new(&fn)
+      LazySeq.new(fn)
     end
 
     def cons(head, tail)
@@ -94,6 +112,19 @@ module Rupture
       List.new(*xs)
     end
 
+    def hash_map(*kvs, &block)
+      h = block_given? ? HashMap.new(&block) : HashMap.empty
+      if kvs.size == 1
+        h.into(kvs.first)
+      else
+        h.assoc(*kvs)
+      end
+    end
+
+    def constantly(x)
+      lambda {x}
+    end
+
     def identity(x)
       x
     end
@@ -108,6 +139,35 @@ module Rupture
       juxt(identity, *args)
     end
 
+    def let(*vals)
+      yield(*vals)
+    end
+
+    def fix(val, pred, f = nil, &fn)
+      fn ||= f
+      pred = pred.to_proc[val] if pred.respond_to?(:to_proc)
+      pred ? fn[val] : val
+    end
+
+    def when_let(val)
+      yield(val) if val
+    end
+
+    def for(s, *seqs, &fn)
+      if seqs.empty?
+        s.seq.map(&fn)
+      else
+        lazy_seq do
+          tails = self.for(*seqs) {|*args| args}
+          s.seq.mapcat do |head|
+            tails.map do |tail|
+              fn[head, *tail]
+            end
+          end
+        end
+      end
+    end
+
     extend Function
     F = Function
   end

data/lib/rupture/hash_map.rb

@@ -0,0 +1,47 @@
+require 'hamster'
+
+module Rupture
+  class HashMap < Hamster::Hash
+    include Map
+
+    def as_map
+      self
+    end
+
+    def self.empty
+      @empty ||= HashMap.new
+    end
+  end
+end
+
+class Hash
+  include Rupture::Map
+
+  def as_map
+    F.hash_map(self)
+  end
+  alias ~ as_map
+
+  def assoc!(*vals)
+    vals.each_slice(2) do |k,v|
+      self[k] = v
+    end
+    self
+  end
+
+  def update!(key, fn = nil, *args, &block)
+    self[key] = if fn
+      fn.call(self[key], *args, &block)
+    else
+      yield(self[key])
+    end
+    self
+  end
+
+  def update_each!(keys, *args, &block)
+    keys.each do |key|
+      update!(key, *args, &block)
+    end
+    self
+  end
+end

data/lib/rupture/lazy_seq.rb

@@ -1,8 +1,7 @@
 module Rupture
   class LazySeq < Seq
-    def initialize(b = nil, &block)
-      @block = block || b
-      super()
+    def initialize(block = nil)
+      @block = block
     end
 
     def seq

data/lib/rupture/list.rb

@@ -6,17 +6,13 @@ module Rupture
     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
+      list = Empty
       args.reverse_each do |x|
         list = list.conj(x)
       end
@@ -27,5 +23,7 @@ module Rupture
     def conj(x)
       self.class.send(:create, Cons.new(x, @seq), @size.inc)
     end
+
+    Empty = create(nil, 0)
   end
 end

data/lib/rupture/map.rb

@@ -0,0 +1,38 @@
+module Rupture
+  module Map
+    def map?
+      true
+    end
+
+    def assoc(*kvs)
+      into(kvs.seq.partition(2))
+    end
+
+    def into(other)
+      other.seq.reduce(as_map) do |map, (k,v)|
+        map.put(k,v)
+      end
+    end
+
+    def update(key, fn = nil, *args, &block)
+      if fn
+        assoc(key, fn.call(self[key], *args, &block))
+      else
+        assoc(key, yield(self[key]))
+      end
+    end
+
+    def update_each(keys, *args, &block)
+      map = as_map
+      keys.each do |key|
+        update(key, *args, &block)
+      end
+      map
+    end
+
+    def destruct(*keys)
+      vals = keys.seq.map(self)
+      block_given? ? yield(*vals) : vals
+    end
+  end
+end

data/lib/rupture/meta.rb

@@ -5,7 +5,7 @@ module Rupture::Meta
 
   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)
+    raise "meta must be of type Hash, it is #{meta.class}" unless meta.nil? or meta.kind_of?(Hash) or meta.kind_of?(Rupture::HashMap)
     copy = super()
     copy.instance_variable_set(:@_meta, meta)
     copy

data/lib/rupture/rails_ext.rb

@@ -36,3 +36,23 @@ class Hash
     dup.stringify_keys!
   end
 end
+
+if defined?(HashWithIndifferentAccess)
+  class HashWithIndifferentAccess
+    def to_hash
+      Hash.new(default).merge(self).with_meta(meta)
+    end
+
+    def symbolize_keys
+      to_hash.symbolize_keys!
+    end
+
+    def deep_symbolize_keys
+      to_hash.deep_symbolize_keys!
+    end
+
+    def stringify_keys
+      to_hash.stringify_keys!
+    end
+  end
+end

data/lib/rupture/reader.rb

@@ -33,22 +33,22 @@ module Rupture
 
     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 '('  then read_list
+      when '['  then read_list(Array, ']')
+      when '{'  then read_map
+      when '"'  then read_string
+      when ':'  then read_keyword
+      when ' '  then read
+      when /\d/ then ungetc(c); read_number
+      when /\w/ then ungetc(c); read_symbol
       when '-'
         case c = getc
-        when /\d/ : ungetc(c);     -read_number
-        else        ungetc('-', c); read_symbol
+        when /\d/ then ungetc(c);     -read_number
+        else           ungetc('-', c); read_symbol
         end
       when '#'
         case c = getc
-        when '{' : read_list(Set, '}')
+        when '{' then read_list(Set, '}')
         end
       end
     end

data/lib/rupture/seq.rb

@@ -1,17 +1,10 @@
 module Rupture
-  class Seq < Enumerable::Enumerator
+  class Seq
+    include Enumerable
     include Sequence
 
-    def initialize
-      super(self)
-    end
-
-    def each
-      s = self
-      while s = s.seq
-        yield s.first
-        s = s.rest
-      end
+    def inspect
+      "(#{to_a.collect(&:inspect).join(',')})"
     end
 
     def [](index)
@@ -22,7 +15,9 @@ module Rupture
       to_a
     end
 
-    def ==(other)
+    def eql?(other)
+      return false unless other.respond_to?(:seq)
+
       s = self.seq
       o = other.seq
       while s && o
@@ -30,18 +25,18 @@ module Rupture
         s = s.next
         o = o.next
       end
+
       s.nil? and o.nil?
     end
+    alias == eql?
 
-    def self.empty
-      @empty ||= EmptySeq.new
+    class EmptySeq < Seq
+      def seq
+        nil
+      end
     end
-  end
 
-  class EmptySeq < Seq
-    def seq
-      nil
-    end
+    Empty = EmptySeq.new
   end
 end
 
@@ -57,6 +52,6 @@ class NilClass
   end
 
   def rest
-    Rupture::Seq.empty
+    Rupture::Seq::Empty
   end
 end

data/lib/rupture/sequence.rb

@@ -24,6 +24,18 @@ module Rupture
       self if seq
     end
 
+    def divide
+      [first, rest]
+    end
+
+    def each
+      s = self
+      while s = s.seq
+        yield s.first
+        s = s.rest
+      end
+    end
+
     def count
       F.loop(0, self) do |recur, i, s|
         if s.empty?
@@ -36,10 +48,6 @@ module Rupture
       end
     end
 
-    def inspect
-      "(#{to_a.collect(&:inspect).join(' ')})"
-    end
-
     def conj(item)
       F.cons(item, self)
     end
@@ -49,7 +57,7 @@ module Rupture
     end
 
     def reverse
-      Seq.empty.into(self)
+      Seq::Empty.into(self)
     end
 
     def take(n)
@@ -77,7 +85,7 @@ module Rupture
         if lead
           recur[s.next, lead.next]
         else
-          s || Seq.empty
+          s || Seq::Empty
         end
       end
     end
@@ -124,18 +132,12 @@ module Rupture
 
     def filter(p = nil, &pred)
       pred ||= p
-      F.lazy_seq do
-        if s = seq
-          i = s.first
-          tail = s.rest.filter(pred)
-          pred[i] ? F.cons(i, tail) : tail
-        end
-      end
+      F.filter(pred, self)
     end
 
     def remove(p = nil, &pred)
       pred ||= p
-      filter(pred.complement)
+      F.remove(pred, self)
     end
 
     def separate(p = nil, &pred)
@@ -154,7 +156,16 @@ module Rupture
 
     def map(f = nil, &fn)
       fn ||= f
-      F.map(fn, self)
+      F.lazy_loop(seq) do |recur, s|
+        F.cons(fn[s.first], recur[s.next]) if s
+      end
+    end
+
+    def map_indexed(f = nil, &fn)
+      fn ||= f
+      F.lazy_loop(0, seq) do |recur, i, s|
+        F.cons(fn[i, s.first], recur[i.inc, s.next]) if s
+      end
     end
 
     def concat(*colls)
@@ -179,6 +190,19 @@ module Rupture
       end
     end
 
+    def reductions(*args, &fn)
+      fn ||= args.shift
+      Utils.verify_args(args, 0, 1)
+      acc, coll = (args.empty? ? divide : [args.first, self])
+
+      F.lazy_loop(acc, coll) do |recur, acc, coll|
+        if coll.seq
+          acc = fn[acc, coll.first]
+          F.cons(acc, recur[acc, coll.rest])
+        end
+      end.conj(acc)
+    end
+
     def foldr(*args, &fn)
       fn ||= args.shift
       reverse.reduce(*args) {|a,b| fn[b,a]}
@@ -253,12 +277,29 @@ module Rupture
       fn ||= f
       F.lazy_seq do
         if s = seq
-          run = F.cons(s.first, s.partition(2,1).take_while {|i| not fn[*i]}.map(:second))
+          run = F.cons(s.first,
+                       s.partition(2,1).take_while {|i| not fn[*i]}.map(:second))
           F.cons(run, s.drop(run.count).partition_between(fn))
         end
       end
     end
 
+    def sort(c = nil, &cmp)
+      cmp||= c
+      super(&cmp).seq
+    end
+
+    def sort_by(f = nil, &fn)
+      fn ||= f
+      sort {|a,b| fn[a] <=> fn[b]}
+    end
+
+    def frequencies
+      reduce(Hash.new(0)) do |counts, x|
+        counts.update!(x, :inc)
+      end
+    end
+
     def doall(n = nil)
       if n
         loop(n, seq) do |recur, n, s|

data/lib/rupture.rb

@@ -14,6 +14,8 @@ require 'rupture/lazy_seq'
 require 'rupture/cons'
 require 'rupture/array_seq'
 require 'rupture/list'
+require 'rupture/map'
+require 'rupture/hash_map'
 
 F = Rupture::Function
 

data/rupture.gemspec

@@ -1,63 +1,22 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-Gem::Specification.new do |s|
-  s.name = %q{rupture}
-  s.version = "0.1.0"
+Gem::Specification.new do |gem|
+  gem.name          = "rupture"
+  gem.version       = IO.read('VERSION')
+  gem.authors       = ["Justin Balthrop", "Alan Malloy"]
+  gem.email         = ["git@justinbalthrop.com"]
+  gem.description   = %q{Clojure sequence functions for Ruby.}
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/flatland/rupture"
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Justin Balthrop"]
-  s.date = %q{2011-09-09}
-  s.description = %q{Clojure sequence functions for Ruby.}
-  s.email = %q{code@justinbalthrop.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.md"
-  ]
-  s.files = [
-    "LICENSE",
-    "README.md",
-    "Rakefile",
-    "VERSION",
-    "init.rb",
-    "lib/rupture.rb",
-    "lib/rupture/array_seq.rb",
-    "lib/rupture/cons.rb",
-    "lib/rupture/core_ext.rb",
-    "lib/rupture/fn.rb",
-    "lib/rupture/function.rb",
-    "lib/rupture/lazy_seq.rb",
-    "lib/rupture/list.rb",
-    "lib/rupture/lookup.rb",
-    "lib/rupture/meta.rb",
-    "lib/rupture/rails_ext.rb",
-    "lib/rupture/reader.rb",
-    "lib/rupture/seq.rb",
-    "lib/rupture/sequence.rb",
-    "lib/rupture/symbol.rb",
-    "lib/rupture/utils.rb",
-    "rupture.gemspec",
-    "test/fn_test.rb",
-    "test/list_test.rb",
-    "test/meta_test.rb",
-    "test/seq_test.rb",
-    "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/flatland/rupture}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.7}
-  s.summary = %q{Clojure sequence functions for Ruby.}
+  gem.add_development_dependency 'shoulda', '3.0.1'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'hamster'
+  gem.add_development_dependency 'rake'
 
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
 end
-

data/test/fn_test.rb

@@ -13,6 +13,11 @@ class FnTest < Test::Unit::TestCase
   #   assert_equal [1,2,3,4,5,6].seq, F[:concat].apply([1],[2],[[3,4],[5,6]])
   # end
 
+  should "fnil replaces nil args" do
+    assert_equal [2,3,4,1,5].seq, [1,2,3,nil,4].seq.map(:inc.fnil(0))
+    assert_equal [1,2,nil,1].seq, [:a,:b,:c,nil].seq.map({:a => 1, :b => 2}.fnil(:a))
+  end
+
   should "use hash as fn" do
     assert_equal [1, 2, 3, nil].seq, [:foo, :bar, :baz, :bam].seq.map({:foo => 1, :bar => 2, :baz => 3})
   end

data/test/function_test.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class FunctionTest < Test::Unit::TestCase
+  should "loop" do
+    n = F.loop(0) do |recur, i|
+      if i < 10
+        recur[i.inc]
+      else
+        i
+      end
+    end
+    assert_equal 10, n
+  end
+
+  should "loop lazily" do
+    s = F.lazy_loop(0) do |recur, i|
+      if i != 10
+        F.cons(i, recur[i.inc])
+      end
+    end
+    assert_equal (0..9).seq, s
+  end
+
+  should "comprehend lists" do
+    assert_equal [[1,3],[1,4],[1,5],[2,3],[2,4],[2,5],[3,3],[3,4],[3,5]].seq,
+                 F.for([1,2,3], [3,4,5]) {|a, b| [a,b]}
+  end
+
+  should "let stuff" do
+    a = 0
+    c = F.let(1,2) do |a,b|
+      assert_equal 1, a
+      assert_equal 2, b
+      a + b
+    end
+    assert_equal 3, c
+
+    assert_equal a, 0 if RUBY_VERSION =~ /1.9/ # 1.8 only has lexical scope for functions.
+
+    c = 1.let(2) do |a,b|
+      assert_equal 1, a
+      assert_equal 2, b
+      a + b
+    end
+    assert_equal 3, c
+
+    assert_equal a, 0 if RUBY_VERSION =~ /1.9/ # 1.8 only has lexical scope for functions.
+  end
+
+  should "when_let" do
+    assert_equal nil, F.when_let(false) {|a| a + 1}
+    assert_equal nil, F.when_let(nil)   {|a| a + 1}
+    assert_equal 2,   F.when_let(1)     {|a| a + 1}
+  end
+
+  should "fix stuff" do
+    assert_equal 1, F.fix(1,:even?,:inc)
+    assert_equal 1, 1.fix(:even?,:inc)
+
+    assert_equal 3, F.fix(2,:even?,:inc)
+    assert_equal 3, 2.fix(:even?,:inc)
+
+    assert_equal 12, F.fix(2,:even?) {|i| i + 10}
+    assert_equal 12, 2.fix(:even?) {|i| i + 10}
+  end
+end

data/test/map_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class MapTest < Test::Unit::TestCase
+  should "destructure" do
+    a,b,c,d = {:foo => 1, :bar => 3}.destruct(:bar, :foo, :bar, :baz)
+
+    assert_equal 3,   a
+    assert_equal 1,   b
+    assert_equal 3,   c
+    assert_equal nil, d
+
+    {:foo => 1, :bar => 3}.destruct(:bar, :foo, :bar, :baz) do |*args|
+      assert_equal [3, 1, 3, nil], args
+    end
+  end
+
+  should "update!" do
+    h = {:foo => 1, :bar => [1,2,3].seq}
+    h.update!(:foo, :inc)
+
+    assert_equal({:foo => 2, :bar => [1,2,3].seq}, h)
+
+    h.update!(:bar, :map) {|i| i + 10}
+    assert_equal({:foo => 2, :bar => [11,12,13].seq}, h)
+
+    h.update!(:foo) {|i| i + 10}
+    assert_equal({:foo => 12, :bar => [11,12,13].seq}, h)
+  end
+
+  should "update" do
+    h = ~{:foo => 1, :bar => [1,2,3].seq}
+
+    assert_equal ~{:foo => 2,  :bar => [1,2,3].seq},    h.update(:foo, :inc)
+    assert_equal ~{:foo => 1,  :bar => [11,12,13].seq}, h.update(:bar, :map) {|i| i + 10}
+    assert_equal ~{:foo => 11, :bar => [1,2,3].seq},    h.update(:foo) {|i| i + 10}
+  end
+end

data/test/seq_test.rb

@@ -1,7 +1,7 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 class SeqTest < Test::Unit::TestCase
-  empty_seqs = [nil, [], Rupture::Seq.empty, F.lazy_seq{nil}, F.lazy_seq{[]}]
+  empty_seqs = [nil, [], Rupture::Seq::Empty, F.lazy_seq{nil}, F.lazy_seq{[]}]
 
   def numbers(i)
     F.lazy_seq { F.cons(i, numbers(i.inc))}
@@ -56,9 +56,9 @@ class SeqTest < Test::Unit::TestCase
   end
 
   should "reverse and rseq" do
-    assert_equal [1,2,3,4].seq,      [4,3,2,1].seq.reverse
-    assert_equal [1,2,3,4].seq,      [4,3,2,1].rseq
-    assert_equal Rupture::Seq.empty, [].seq.reverse
+    assert_equal [1,2,3,4].seq,       [4,3,2,1].seq.reverse
+    assert_equal [1,2,3,4].seq,       [4,3,2,1].rseq
+    assert_equal Rupture::Seq::Empty, [].seq.reverse
   end
 
   should "count" do
@@ -80,6 +80,10 @@ class SeqTest < Test::Unit::TestCase
     assert_equal [9,12,15].seq, [3,4,5].seq.map {|a| a * 3}
   end
 
+  should "map_indexed" do
+    assert_equal [2,4,6,8].seq, [2,3,4,5].seq.map_indexed {|i, a| i + a}
+  end
+
   should "concat" do
     assert_equal [1,2,3,4,5,6].seq, F.concat([1,2],[3,4,5],[6])
     assert_equal [1,2,3,4,5,6].seq, [1,2].seq.concat([3,4,5],[6])
@@ -99,6 +103,11 @@ class SeqTest < Test::Unit::TestCase
     assert_equal 240, [1,2,3,4].seq.reduce(:*, 10)
   end
 
+  should "reducutions" do
+    assert_equal [1,3,6,10].seq,        [1,2,3,4].seq.reductions(:+)
+    assert_equal [10,10,20,60,240].seq, [1,2,3,4].seq.reductions(:*, 10)
+  end
+
   should "foldr" do
     assert_equal F.list(1,2,3,4), [1,2,3,4].seq.foldr(F[:cons], nil)
   end
@@ -252,4 +261,13 @@ class SeqTest < Test::Unit::TestCase
   should "partition_between" do
     assert_equal [[1], [nil, 4, 3], [nil, 8]].seq.map(:seq), [1,nil,4,3,nil,8].seq.partition_between {|a,b| b == nil}
   end
+
+  should "sort_by" do
+    assert_equal [[:foo,1],[:baz,2],[:bar,5]].seq,
+                 [[:foo,1],[:bar,5],[:baz,2]].seq.sort_by(:last)
+  end
+
+  should "calculate frequencies" do
+    assert_equal({1=>3, nil=>2, 2=>1}, [1,nil,2,1,nil,1].seq.frequencies)
+  end
 end

data/test/test_helper.rb

@@ -1,7 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
-require 'mocha'
+require 'mocha/setup'
 require 'pp'
 
 $LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"

metadata

@@ -1,48 +1,110 @@
 --- !ruby/object:Gem::Specification 
 name: rupture
 version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
+  hash: 23
+  prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Justin Balthrop
+- Alan Malloy
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2011-09-09 00:00:00 -07:00
+date: 2013-08-13 00:00:00 -07:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 3
+        - 0
+        - 1
+        version: 3.0.1
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hamster
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
 description: Clojure sequence functions for Ruby.
-email: code@justinbalthrop.com
+email: 
+- git@justinbalthrop.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.md
+extra_rdoc_files: []
+
 files: 
+- .gitignore
+- .rbenv-version
+- Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - VERSION
-- init.rb
 - lib/rupture.rb
 - lib/rupture/array_seq.rb
 - lib/rupture/cons.rb
 - lib/rupture/core_ext.rb
 - lib/rupture/fn.rb
 - lib/rupture/function.rb
+- lib/rupture/hash_map.rb
 - lib/rupture/lazy_seq.rb
 - lib/rupture/list.rb
 - lib/rupture/lookup.rb
+- lib/rupture/map.rb
 - lib/rupture/meta.rb
 - lib/rupture/rails_ext.rb
 - lib/rupture/reader.rb
@@ -52,12 +114,14 @@ files:
 - lib/rupture/utils.rb
 - rupture.gemspec
 - test/fn_test.rb
+- test/function_test.rb
 - test/list_test.rb
+- test/map_test.rb
 - test/meta_test.rb
 - test/seq_test.rb
 - test/test_helper.rb
 has_rdoc: true
-homepage: http://github.com/flatland/rupture
+homepage: https://github.com/flatland/rupture
 licenses: []
 
 post_install_message: 
@@ -86,9 +150,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: Clojure sequence functions for Ruby.
-test_files: []
-
+test_files: 
+- test/fn_test.rb
+- test/function_test.rb
+- test/list_test.rb
+- test/map_test.rb
+- test/meta_test.rb
+- test/seq_test.rb
+- test/test_helper.rb

data/init.rb

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