sequence 0.1.0

data/lib/sequence/functional.rb

@@ -0,0 +1,152 @@
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+  
+class Sequence
+  #i thought ruby had this already, but i can't find it...
+  class WeakHash
+    #dunno if this is thread-safe
+    def initialize hash={},default=nil,&block
+      @hash=block ? Hash.new(&block) : Hash.new(default)
+      hash.each{|(k,v)|
+        self[k]=v    
+      }
+    end
+    
+    def delete_when_dies key
+      ObjectSpace.define_finalizer(key){|id| @hash.include? id and @hash.delete id}  
+      return key
+    end
+    
+    def [] key
+      @hash[key.__id__]
+    end
+    
+    def []= key, val
+      delete_when_dies key
+      @hash[key.__id__]=val
+    end
+    
+    def delete key
+      @hash.delete key.__id__
+    end
+    
+    def values
+      @hash.values
+    end
+    
+    def keys
+      @hash.keys.map!{|id| ObjectSpace._id2ref(id)}
+    end
+  end
+
+  #methods (and constants) related to functional programming
+  module Functional;  end
+  class<<Functional  
+    HAS_SIDE_EFFECT=WeakHash.new
+    NO_SIDE_EFFECT=WeakHash.new
+    #hashes of Module (or Class, including meta-Class) to a list of method names
+    #which do or don't have side effects
+    def functions_of(obj)
+      published=Set[public_methods_of(obj).delete_if{|name| /[!=]$/===name}]
+      result=[]
+      list=class<<obj; ancestors.unshift self end
+      list.each{|mod| 
+        result.push( *published&NO_SIDE_EFFECT[mod] )
+        published&=Set[*NO_SIDE_EFFECT[mod]+HAS_SIDE_EFFECT[mod]]
+      }
+      return result
+    end
+    
+    def maybe_functions_of(obj)
+      published=public_methods_of(obj).delete_if{|name| /[!=]$/===name}
+      result=[]
+      list=class<<obj; ancestors.unshift self end
+      list.each{|mod| 
+        published.delete_if{|name| 
+          NO_SIDE_EFFECT[mod].include? name || 
+          HAS_SIDE_EFFECT[mod].include? name
+        }
+      }
+      return result
+    end
+   
+    def nonfunctions_of(obj)
+      public_methods_of(obj)-functions_of(obj)-maybe_functions_of(obj)
+    end
+    
+    def is_function?(obj,name)
+      list=class<<obj; ancestors.unshift self end
+      list.each{|mod| 
+        return true if NO_SIDE_EFFECT[mod].include? name
+        return false if HAS_SIDE_EFFECT[mod].include? name
+      }
+      return false
+    end
+    
+    def is_maybe_not_function?(obj,name)
+      !is_function(obj,name)
+    end
+    
+    def is_maybe_function?(obj,name)
+      list=class<<obj; ancestors.unshift self end
+      list.each{|mod| 
+        return true if NO_SIDE_EFFECT[mod].include? name
+        return false if HAS_SIDE_EFFECT[mod].include? name
+      } 
+      return true
+    end
+    
+    def is_not_function?(obj,name)
+      !is_maybe_function(obj,name)
+    end
+
+    PMETHS_REF= ::Object.instance_method("public_methods")
+    def public_methods_of(obj)
+      PMETHS_REF.bind(obj).call
+    end
+  end
+
+end
+
+class Module
+  def has_side_effect(*names)
+    names.map!{|name| name.to_s}
+    Functional::HAS_SIDE_EFFECT[self]|= names
+    Functional::NO_SIDE_EFFECT[self] -= names
+  end
+  
+  def no_side_effect(*names)
+    names.map!{|name| name.to_s}
+    Functional::NO_SIDE_EFFECT[self] |= names
+    Functional::HAS_SIDE_EFFECT[self]-=names
+  end
+end
+
+class Object
+  has_side_effect *l=%w(__send__ display extend freeze instance_eval instance_exec instance_variable_set method_missing send taint untaint)
+  no_side_effect *instance_methods(false)-l
+end
+class String
+  has_side_effect  *l=%w(<< []= capitalize! chomp! chop! concat delete! downcase! gsub! lstrip! next! replace reverse! rstrip! slice! squeeze! strip! sub! succ! swapcase! tr! tr_s! upcase!)
+  no_side_effect  *instance_methods(false)-l
+end
+class Array
+  has_side_effect  *l=%w(<< []= clear collect! compact! concat delete delete_at delete_if fill flatten! insert map! pop push reject! replace reverse! shift slice! sort! uniq! unshift)
+  no_side_effect  *instance_methods(false)-l
+end
+class Hash
+  has_side_effect  *l=%w([]= clear default= delete delete_if merge! rehash reject! replace shift store update)
+  no_side_effect  *instance_methods(false)-l
+end
+class Class
+  has_side_effect *%w(inheirited new)
+  no_side_effect *%w(allocate superclass)
+end
+class Module
+  has_side_effect  *l=%w(class_eval const_set module_eval private_class_method public_class_method)+private_instance_methods(false)-["class_variable_get"]
+  no_side_effect  *["class_variable_get"]+instance_methods(false)-l
+end
+class Proc
+  has_side_effect *%w[[] call]
+  no_side_effect "arity"
+end

data/lib/sequence/generator.rb

@@ -0,0 +1,290 @@
+#!/usr/bin/env ruby
+#--
+# $Idaemons: /home/cvs/rb/generator.rb,v 1.8 2001/10/03 08:54:32 knu Exp $
+# $RoughId: generator.rb,v 1.10 2003/10/14 19:36:58 knu Exp $
+# $Id: generator.rb,v 1.12 2005/12/31 02:56:46 ocean Exp $
+#++
+
+#this is a copy of (the newest, fastest) generator.rb from the standard lib,
+#with SyncEnumerator removed. -cc
+
+#
+# = generator.rb: convert an internal iterator to an external one
+#
+# Copyright (c) 2001,2003 Akinori MUSHA <knu@iDaemons.org>
+#
+# All rights reserved.  You can redistribute and/or modify it under
+# the same terms as Ruby.
+#
+# == Overview
+#
+# This library provides the Generator class, which converts an
+# internal iterator (i.e. an Enumerable object) to an external
+# iterator.  In that form, you can roll many iterators independently.
+#
+# The SyncEnumerator class, which is implemented using Generator,
+# makes it easy to roll many Enumerable objects synchronously.
+#
+# See the respective classes for examples of usage.
+
+
+#
+# Generator converts an internal iterator (i.e. an Enumerable object)
+# to an external iterator.
+#
+# == Example
+#
+#   require 'generator'
+#
+#   # Generator from an Enumerable object
+#   g = Generator.new(['A', 'B', 'C', 'Z'])
+#
+#   while g.next?
+#     puts g.next
+#   end
+#
+#   # Generator from a block
+#   g = Generator.new { |g|
+#     for i in 'A'..'C'
+#       g.yield i
+#     end
+#
+#     g.yield 'Z'
+#   }
+#
+#   # The same result as above
+#   while g.next?
+#     puts g.next
+#   end
+#   
+
+#if existing Generator library is the slow one, replace with the faster version (above)
+require 'generator.rb'
+unless Generator.new.instance_variables.include("@loop_thread") 
+  remove_const :Generator
+class Generator
+  include Enumerable
+
+  # Creates a new generator either from an Enumerable object or from a
+  # block.
+  #
+  # In the former, block is ignored even if given.
+  #
+  # In the latter, the given block is called with the generator
+  # itself, and expected to call the +yield+ method for each element.
+  def initialize(enum = nil, &block)
+    if enum
+      @block = proc{|g| enum.each{|value| g.yield value}}
+    else
+      @block = block
+    end
+    @index = 0
+    @queue = []
+    @main_thread = nil
+    @loop_thread.kill if defined?(@loop_thread)
+    @loop_thread = Thread.new do
+      Thread.stop
+      begin
+        @block.call(self)
+      rescue
+        @main_thread.raise $!
+      ensure
+        @main_thread.wakeup
+      end
+    end
+    Thread.pass until @loop_thread.stop?
+    self
+  end
+
+  # Yields an element to the generator.
+  def yield(value)
+    if Thread.current != @loop_thread
+      raise "should be called in Generator.new{|g| ... }"
+    end
+    Thread.critical = true
+    begin
+      @queue << value
+      @main_thread.wakeup
+      Thread.stop
+    ensure
+      Thread.critical = false
+    end
+    self
+  end
+
+  # Returns true if the generator has reached the end.
+  def end?
+    if @queue.empty?
+      if @main_thread
+        raise "should not be called in Generator.new{|g| ... }"
+      end
+      Thread.critical = true
+      begin
+        @main_thread = Thread.current
+        @loop_thread.wakeup
+        Thread.stop
+      rescue ThreadError
+        # ignore
+      ensure
+        @main_thread = nil
+        Thread.critical = false
+      end
+    end
+    @queue.empty?
+  end
+
+  # Returns true if the generator has not reached the end yet.
+  def next?
+    !end?
+  end
+
+  # Returns the current index (position) counting from zero.
+  def index
+    @index
+  end
+
+  # Returns the current index (position) counting from zero.
+  def pos
+    @index
+  end
+
+  # Returns the element at the current position and moves forward.
+  def next
+    raise EOFError.new("no more elements available") if end?
+    @index += 1
+    @queue.shift
+  end
+
+  # Returns the element at the current position.
+  def current
+    raise EOFError.new("no more elements available") if end?
+    @queue.first
+  end
+
+  # Rewinds the generator.
+  def rewind
+    initialize(nil, &@block) if @index.nonzero?
+    self
+  end
+
+  # Rewinds the generator and enumerates the elements.
+  def each
+    rewind
+    until end?
+      yield self.next
+    end
+    self
+  end
+end
+end
+
+
+
+if $0 == __FILE__
+  eval DATA.read, nil, $0, __LINE__+4
+end
+
+__END__
+
+require 'test/unit'
+
+class TC_Generator < Test::Unit::TestCase
+  def test_block1
+    g = Generator.new { |g|
+      # no yield's
+    }
+
+    assert_equal(0, g.pos)
+    assert_raises(EOFError) { g.current }
+  end
+
+  def test_block2
+    g = Generator.new { |g|
+      for i in 'A'..'C'
+        g.yield i
+      end
+
+      g.yield 'Z'
+    }
+
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+
+    assert_equal(true, g.next?)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.next)
+
+    assert_equal(1, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.current)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.next)
+
+    assert_equal(g, g.rewind)
+
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+
+    assert_equal(true, g.next?)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.current)
+    assert_equal(0, g.pos)
+    assert_equal('A', g.next)
+
+    assert_equal(1, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.current)
+    assert_equal(1, g.pos)
+    assert_equal('B', g.next)
+
+    assert_equal(2, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(2, g.pos)
+    assert_equal('C', g.current)
+    assert_equal(2, g.pos)
+    assert_equal('C', g.next)
+
+    assert_equal(3, g.pos)
+    assert_equal(true, g.next?)
+    assert_equal(3, g.pos)
+    assert_equal('Z', g.current)
+    assert_equal(3, g.pos)
+    assert_equal('Z', g.next)
+
+    assert_equal(4, g.pos)
+    assert_equal(false, g.next?)
+    assert_raises(EOFError) { g.next }
+  end
+
+  def test_each
+    a = [5, 6, 7, 8, 9]
+
+    g = Generator.new(a)
+
+    i = 0
+
+    g.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+
+      break if i == 3
+    }
+
+    assert_equal(3, i)
+
+    i = 0
+
+    g.each { |x|
+      assert_equal(a[i], x)
+
+      i += 1
+    }
+
+    assert_equal(5, i)
+  end
+end

data/lib/sequence/indexed.rb

@@ -0,0 +1,234 @@
+# $Id$
+# Copyright (C) 2006  Caleb Clausen
+# Distributed under the terms of Ruby's license.
+
+require 'sequence'
+require 'sequence/arraylike'
+require 'sequence/stringlike'
+require 'sequence/usedata'
+require 'sequence/subseq'
+
+class Sequence
+# This class makes a seq over an Array or String.
+class Indexed < UseData
+
+class <<self
+  alias _orig_new new
+  def new(data,p=0)
+    if data.respond_to? :to_sequence
+      data.to_sequence
+    else _orig_new(data,p)
+    end
+  end
+end
+
+    def initialize(data,pos=0)
+        @data = data
+        @pos = pos
+    end
+    # :stopdoc:
+    def new_data
+        @data.class.new
+    end
+
+=begin
+    protected
+    def _delete1after?
+        @data.slice!(@pos)
+    end
+    def _delete1before?
+        @pos==0 ? nil : @data.slice!(@pos-=1)
+    end
+    def _insert1before(v)
+        @data[@pos,0] = (new_data << v)
+        @pos += 1
+        true
+    end
+    def _insert1after(v)
+        @data[@pos,0] = (new_data << v)
+        true
+    end
+public
+=end
+   
+    attr_reader :pos,:data
+    def _pos= x; @pos=x end
+    
+    def eof?; @pos >= size end
+    
+    def_delegators :@data, :size, :slice, :[]
+    
+    def maxmatchlen(backwards) size end
+    
+    #can't change maxmatchlen (maybe someday?)
+    def maxmatchlen= x; end
+    
+    def modify(*args)
+      newsize=args.last.size
+      first,len,only1=_parse_slice_args( *args[0...-1])
+      @data.[]=(*args)
+      @pos=_adjust_pos_on_change(@pos, first,len,newsize)
+      notify_change(self,first,len,newsize)      
+      return args.last
+    end
+    alias []= modify
+    
+end
+
+class OfArray < Indexed
+  class<<self
+    alias new _orig_new
+  end
+  include ArrayLike
+  #scan,scan_until provided by ArrayLike
+  
+  #a better, string-like #index... with an offset parameter
+  #scalar matchers only
+  def index(pat,offset=0)
+    pat=pat.dup
+    class<<pat; alias == ===; end
+    offset.zero? and return( @data.index pat)
+    @data[offset..-1].index(pat)+offset
+  end
+    
+  #a better, string-like #rindex... with an offset parameter
+  #scalar matchers only
+  def rindex(pat,offset=size)
+    pat=pat.dup
+    class<<pat; alias == ===; end
+    (offset==size ? @data : @data[0...offset]).rindex pat
+  end
+    
+  def append(arr)
+    sz=size
+    @data.push(*arr)
+    notify_change(self,sz,0,arr.size)
+    self
+  end
+
+  def new_data
+    []
+  end
+
+end
+
+class OfString < Indexed
+  class<<self
+    alias new _orig_new
+  end
+
+  include StringLike
+  def scan(pat)
+    holding?{case pat
+    when Regexp:
+      if (m=match pat,true)
+        @pos= m.end(0)
+        m.to_s
+      end
+    when Integer: (res=@data[@pos])==pat and @pos+=1 and res 
+    when String: @data[@pos...@pos+=pat.size]==pat and pat
+    end}
+  end
+
+  def scanback(pat)
+    holding?{case pat
+    when Regexp:
+      if m=matchback(pat,true) 
+        @pos= m.begin(0)
+        m.to_s
+      end
+    when Integer:  @data[@pos-=1]==pat and pat.chr 
+    when String: @data[@pos-=pat.size,pat.size]==pat and pat
+    end}
+  end
+
+  def scan_until(pat)
+    if Regexp===pat
+      return(if (m=match pat,false) 
+        @pos= m.end(0)
+        m.pre_match+m.to_s
+      end)
+    end
+    i=@data.index(pat,pos) or return
+    @data[@pos...@pos=i]
+  end
+  
+  def scanback_until(pat)
+    if Regexp===pat
+      return(if (m=matchback pat,true)
+        @pos= m.begin(0) 
+        m.to_s+m.post_match
+      end)
+    end
+    i=@data.rindex(pat,pos) or return
+    oldpos=@pos
+    @data[@pos=i...oldpos]
+  end
+  
+  def match pat,anchored=true,len=size
+    len=size
+    anchored and pat=_anchor(pat)
+    #pat.last_match=
+    self.last_match=Thread.current[:last_match]= 
+      #can't use String#index here... doesn't do anchors right
+      if pat.match @data[pos..-1]
+        newpos=@pos+$~.end(0)
+        fixup_match_result( $~,[],@pos,:post){
+          SubSeq.new(self,newpos,size-newpos)
+        } 
+      end
+  end
+
+  def matchback pat,anchored=true
+    anchored and pat=_anchor(pat,:back)
+    #pat.last_match=
+    self.last_match=Thread.current[:last_match]=
+    if pat.match @data[0...pos]
+      fixup_match_result($~,[],0,:pre){
+        cu=SubSeq.new(self,0,pos=$~.pre_match.size)    
+        cu.pos=pos
+        cu
+      }
+    end
+  end
+    
+  def index(pat,offset=0)
+    @data.index(pat,offset)
+  end
+
+  def rindex(pat,offset=0)
+    @data.rindex(pat,offset)
+  end
+
+    
+  def append(str)
+    sz=size
+    @data << str
+    notify_change(self,sz,0,str.size)
+    self
+  end
+
+  def new_data
+    ""
+  end
+
+
+end
+
+end
+
+class Array
+    # convert an array to a seq starting at +pos+
+    def to_sequence(pos=0)
+       Sequence::OfArray.new(self,pos)
+    end
+end
+
+class String
+    # convert a string to a seq starting at +pos+
+    def to_sequence (pos=0)
+       Sequence::OfString.new(self,pos)
+    end
+end
+
+