mack-facets 0.8.2 → 0.8.3

data/lib/gems/facets-2.4.5/lib/more/facets/elementor.rb

@@ -1,133 +0,0 @@
-# = Elementor
-#
-# Provides elementwise functionality.
-#
-# == Authors
-#
-# * Thomas Sawyer
-# * George Moschovitis
-# * Martin DeMello
-#
-# == Notes
-#
-# * This could have been impemented with a generic Functor, rather than
-#   the specialized Elementor, but for the fact Procs can not yet
-#   handle blocks.
-# * There used to be a "Cascading Elementor", but that proved idiotic
-#   in the face of adding an instance_eval block to #every.
-# * Any ideas for a better name for #accumulate? --gmosx
-# * The use of every! and it's relation to Enumerator still seems a bit
-#   off beat. Should #every always use #map? And another method #each?
-#
-# == Copying
-#
-# Copyright (c) 2006 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
-require 'enumerator'
-require 'facets/functor'
-
-module Enumerable
-
-  # Create Elementor.
-
-  def to_elem(meth=nil)
-    Elementor.new(self, meth || :map)
-  end
-
-  def per
-    @__per__ ||= Functor.new do |op|
-      Elementor.new(self, op)
-    end
-  end
-
-  # Returns an elemental object. This allows
-  # you to map a method on to every element.
-  #
-  #   r = [1,2,3].every + 3  #=> [4,5,6]
-
-  def every
-    @_every ||= to_elem
-  end
-
-  # In place version of #every.
-
-  def every!
-    raise NoMethodError unless respond_to?(:map!)
-    @_every_inplace ||= to_elem(:map!)
-  end
-
-  #def every
-  #  @_every ||= Functor.new do |op,*args|
-  #    map{ |a| a.send(op,*args) }
-  #  end
-  #end
-
-  #def every!
-  #  raise NoMethodError unless respond_to?(:map!)
-  #  @_every_inplace ||= Functor.new do |op,*args|
-  #    map!{ |a| a.send(op,*args) }
-  #  end
-  #end
-
-  # Possible name change for every.
-  #
-  #   r = [1,2,3].elements + 3  #=> [4,5,6]
-  #
-  # Certainly reads better.
-
-  alias_method :elements, :every
-  alias_method :elements!, :every!
-
-end
-
-
-# = Elementor
-#
-# Elementor is a type of Functor. Operations
-# applied to it are routed to each element.
-
-class Enumerable::Elementor
-  private(*instance_methods.select{|x| x !~ /^__/ })
-
-  def initialize(elem_object, elem_method=nil)
-    @elem_object = elem_object
-    @elem_method = elem_method || :map
-  end
-
-  def instance_delegate
-    @elem_object
-  end
-
-  def instance_operator
-    @elem_method
-  end
-
-  def method_missing(sym,*args,&blk)
-    @elem_object.__send__(@elem_method){ |x| x.__send__(sym,*args,&blk) }
-  end
-end
-
-
-class Enumerable::Enumerator
-
-  # Create Elementor.
-
-  def to_elem(meth=nil)
-    Elementor.new(self, meth || :each)
-  end
-
-  # Enumerator doesn't support inplace element operations, per se.
-
-  undef_method :every!
-  undef_method :elements!
-end
-

data/lib/gems/facets-2.4.5/lib/more/facets/elementwise.rb

@@ -1,61 +0,0 @@
-require 'facets/functor'
-
-module Enumerable
-
-  # Returns an elementwise Functor designed to make R-like
-  # elementwise operations possible.
-  #
-  #   [1,2].elementwise + 3          #=> [4,5]
-  #   [1,2].elementwise + [4,5]      #=> [5,7]
-  #   [1,2].elementwise + [[4,5],3]  #=> [[5,7],[4,5]
-  #
-  #--
-  # Special thanks to Martin DeMello for helping to develop this.
-  #++
-
-  def elementwise(count=1)
-    @_elementwise_functor ||= []
-    @_elementwise_functor[count] ||= Functor.new do |op,*args|
-      if args.empty?
-        r = self
-        count.times do
-          r = r.collect{ |a| a.send(op) }
-        end
-        r
-      else
-        r = args.collect do |arg|
-          if Array === arg #arg.kind_of?(Enumerable)
-            x = self
-            count.times do
-              ln = (arg.length > length ? length : arg.length )
-              x = x.slice(0...ln).zip(arg[0...ln]).collect{ |a,b| a.send(op,b) }
-              #slice(0...ln).zip(arg[0...1n]).collect{ |a,b| b ? a.send(op,b) : nil }
-            end
-            x
-          else
-            x = self
-            count.times do
-              x = x.collect{ |a| a.send(op,arg) }
-            end
-            x
-          end
-        end
-        r.flatten! if args.length == 1
-        r
-      end
-    end
-  end
-
-  # Concise alias for #elementwise.
-  #
-  #   a = [1,2]
-  #   a.ewise + 3          #=> [4,5]
-  #   a.ewise + [4,5]      #=> [5,7]
-  #   a.ewise + [[4,5],3]  #=> [[5,7],[4,5]
-  #
-  # Note this used to be #ew as weel as the '%' operator.
-  # Both of whihc are deprecated.
-
-  alias_method :ewise, :elementwise
-
-end

data/lib/gems/facets-2.4.5/lib/more/facets/enumerablepass.rb

@@ -1,217 +0,0 @@
-# = EnumerablePass
-#
-# This is a simple reimplementation of the core Enumerable module
-# to allow the methods to take and pass-on arbitrary arguments to the
-# underlying #each call. This library uses Enumerator and scans
-# Enumerable so it can alwasy stay in sync.
-#
-# NOTE Any Enumerable method with a negative arity cannot do pass arguments
-# due to ambiguity in the argument count. So the methods #inject and #zip
-# do NOT work this way, but simply work as they do in Enumerable.
-# The method #find (and #detect) though has been made to work by removing
-# its rarely used optional parameter and providing instead an optional
-# keyword parameter (:ifnone => ...). Please keep these difference in mind.
-#
-#   class T
-#     include EnumerablePass
-#     def initialize(arr)
-#       @arr = arr
-#     end
-#     def each(n)
-#       arr.each{ |e| yield(e+n) }
-#     end
-#   end
-#
-#   t = T.new([1,2,3])
-#   t.collect(4)
-#   #=> [5,6,7]
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
-require 'enumerator'
-
-# = EnumerablePass
-#
-# This is a simple reimplementation of the core Enumerable module
-# to allow the methods to take and pass-on arbitrary arguments to the
-# underlying #each call. This library uses Enumerator and scans
-# Enumerable so it can alwasy stay in sync.
-#
-# NOTE Any Enumerable method with a negative arity cannot do pass arguments
-# due to ambiguity in the argument count. So the methods #inject and #zip
-# do NOT work this way, but simply work as they do in Enumerable.
-# The method #find (and #detect) though has been made to work by removing
-# its rarely used optional parameter and providing instead an optional
-# keyword parameter (:ifnone => ...). Please keep these difference in mind.
-#
-#   class T
-#     include EnumerablePass
-#     def initialize(arr)
-#       @arr = arr
-#     end
-#     def each(n)
-#       arr.each{ |e| yield(e+n) }
-#     end
-#   end
-#
-#   t = T.new([1,2,3])
-#   t.collect(4)
-#   #=> [5,6,7]
-#
-module EnumerablePass
-
-  def self.wrap_enumerable_method( methodname )
-
-    m = methodname
-    meth = Enumerable.instance_method(m)
-    arity = meth.arity
-
-    case arity <=> 0
-    when 0
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each, *args).#{m}( &yld )
-        end
-      }
-    when 1
-      class_eval %{
-        def #{m}( *args, &yld )
-          args, each_args = args[0...#{arity}], args[#{arity}..-1]
-          enum_for(:each, *each_args).#{m}( *args, &yld )
-        end
-      }
-    else
-      class_eval %{
-        def #{m}( *args, &yld )
-          enum_for(:each).#{m}( *args, &yld )
-        end
-      }
-    end
-  end
-
-  Enumerable.instance_methods(false).each do |m|
-    wrap_enumerable_method( m )
-  end
-
-  # Make exception for #find (a negative arity method) to accept
-  # keyword argument.
-  #
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #   ObjectSpace.find(Class, :ifnone=>lambda{1}) { |e| ... }
-  #
-  def find(*args, &yld)  # future use **keys ?
-    if Hash === args.last and args.last.key?(:ifnone)
-      ifnone = args.last.delete(:ifnone)
-      args.pop if args.last.empty?
-      enum_for(:each, *args).find( ifnone, &yld )
-    else
-      enum_for(:each, *args).find( &yld )
-    end
-  end
-  alias_method :detect, :find
-
-end
-
-
-=begin  OLD CODE
-module EnumerableArgs
-
-  def collect(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << yield(n) }
-    a
-  end
-  alias_method( :map, :collect )
-
-  def detect(*args)  # :yield:
-    each(*args){ |n| return n if yield(n) }
-    nil
-  end
-  alias_method( :find, :detect )
-
-  def each_with_index(*args)
-    i=0
-    each(*args){ |*n| n << i; yield(*n); i+=1 }
-    self
-  end
-
-  def to_a(*args)
-    a = []
-    each(*args){ |n| a << n }
-    a
-  end
-  alias_method( :entries, :to_a )
-
-  # An additional method not part of standard Enumerable.
-  # The regular version of this method can be found in Facets,
-  # but it is a bit more advanced then this one.
-  # At some point they need to be put into sync.
-  def each_slice(*args, &yld)
-    a = []; s = []
-    ar = yld.arity.abs
-    each(*args){ |n|
-      s << n
-      if s.length >= ar
-        yld.call(*s)
-        s = []
-      end
-    }
-    a
-  end
-  alias_method( :each_by, :each_slice )
-
-  def select(*args)  # :yield:
-    a = []
-    each(*args){ |n| a << n if yield(n) }
-    a
-  end
-  alias_method( :find_all, :select )
-
-  def grep(pattern, *args)
-    a = []
-    each(*args){ |n| a << (block_given? ? yield(n) : n) if pattern === n }
-    a
-  end
-
-  def include?(anObj, *args)
-    each(*args){ |n| return true if anObj == n }
-    false
-  end
-  alias_method( :member?, :include? )
-
-  def max(*args)
-    to_a(*args).max
-  end
-
-  def min(*args)
-    to_a(*args).min
-  end
-
-  def reject(*args)
-    a = []
-    each(*args){ |n| a << n if ! yield(n) }
-    a
-  end
-
-  def sort(*args)
-    # TODO
-  end
-
-end
-=end
-

data/lib/gems/facets-2.4.5/lib/more/facets/equatable.rb

@@ -1,120 +0,0 @@
-# = Equatable
-#
-# This mixin provides methods of equality based
-# on a single #identity method which must return
-# a list of accessors used as the identity keys.
-#
-# It also provides a "shortcut" for creating the
-# #identity method based on given accessors and returns
-# the Equatable module for inclusion.
-#
-#   include Equatable(:a, :b)
-#
-# is equivalent to including a module containing:
-#
-#   def ==(other)
-#     self.a == other.a && self.b == other.b
-#   end
-#
-#   def eql?(other)
-#     self.a.eql?(other.a) && self.b.eql?(other.b)
-#   end
-#
-#   def hash()
-#     self.a.hash ^ self.b.hash
-#   end
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# Copyright (c) 2004 Thomas Sawyer
-#
-# Ruby License
-#
-# This module is free software. You may use, modify, and/or redistribute this
-# software under the same terms as Ruby.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.
-
-
-# = Equatable
-#
-# This mixin provides methods of equality based
-# on a single #identity method which must return
-# a list of accessors used as the identity keys.
-#
-# It also provides a "shortcut" for creating the
-# #identity method based on given accessors and returns
-# the Equatable module for inclusion.
-#
-#   include Equatable(:a, :b)
-#
-# is equivalent to including a module containing:
-#
-#   def ==(other)
-#     self.a == other.a && self.b == other.b
-#   end
-#
-#   def eql?(other)
-#     self.a.eql?(other.a) && self.b.eql?(other.b)
-#   end
-#
-#   def hash()
-#     self.a.hash ^ self.b.hash
-#   end
-#
-module Equatable
-
-  def self.identify(base, *accessors)
-    base.send(:define_method, :identity){ accessors }
-    self
-  end
-
-  def ==(o)
-    identity.all?{ |a| send(a) == o.send(a) }
-  end
-
-  def eql?(o)
-    identity.all?{ |a| send(a).eql?(o.send(a)) }
-  end
-
-  def hash
-    identity.inject(0){ |memo, a| memo ^ send(a).hash }
-  end
-
-end
-
-class Module
-
-  # This function provided a "shortcut" for creating the
-  # #identity method based on given accessors and returns
-  # the Equatable module for inclusion.
-  #
-  #  include Equatable(:a, :b)
-  #
-  # is equivalent to including a module containing:
-  #
-  #   def ==(other)
-  #     self.a == other.a && self.b == other.b
-  #   end
-  #
-  #   def eql?(other)
-  #     self.a.eql?(other.a) && self.b.eql?(other.b)
-  #   end
-  #
-  #   def hash()
-  #     self.a.hash ^ self.b.hash
-  #   end
-  #
-
-  def Equatable(*accessors)
-    Equatable.identify(self, *accessors)
-  end
-
-end
-