Class: Tuple

Class | Tuple
In: | lib/more/facets/tuple.rb
Parent: | Object

# Tuple

A tuple can be made using new or #[] just as one builds an array, or using the to_t method on a string or array. With a string tuple remembers the first non-alphanumeric character as the tuple divider.

## Usage

      t1 = Tuple[1,2,3]
      t2 = Tuple[2,3,4]

      t1 < t2   #=> true
      t1 > t2   #=> false

      t1 = '1.2.3'.to_t
      t2 = '1-2-3'.to_t

      puts t1  #=> 1.2.3
      puts t2  #=> 1-2-3

      t1 == t2  #=> true

Keep in mind that Tuple[1,2,3] is not the same as Tuple[‘1’,’2’,’3’].

### Methods

<< <=> =~ [] [] []= cast_from_array cast_from_string constraint_to_lambda divider each each_index empty? eql? first hash index inspect last length major minor multiton_id new parse_constraint pop pot pull push rindex shift size teeny to_a to_ary to_s to_t to_tuple unshift values

### Included Modules

::Multiton ::Enumerable ::Comparable

### Attributes

default | [RW] |

### Public Class methods

[]( *args )

[Source]

    # File lib/more/facets/tuple.rb, line 226
        def []( *args )
          instance( args )
        end

cast_from_array( arr )

[Source]

    # File lib/more/facets/tuple.rb, line 257
        def cast_from_array( arr )
          self.instance( arr )
        end

cast_from_string( str, &yld )

Translates a string in the form on a set of numerical and/or alphanumerical characters separated by non-word characters (eg \W+) into a Tuple. The values of the tuple will be converted to integers if they are purely numerical.

      Tuple.cast_from_string('1.2.3a')  #=> [1,2,"3a"]

It you would like to control the interpretation of each value as it is added to the tuple you can supply a block.

      Tuple.cast_from_string('1.2.3a'){ |v| v.upcase }  #=> ["1","2","3A"]

This method is called by String#to_t.

[Source]

    # File lib/more/facets/tuple.rb, line 244
        def cast_from_string( str, &yld )
          args = str.to_s.split(/\W+/)
          div = /\W+/.match( str.to_s )[0]
          if block_given?
            args = args.collect{ |a| yld[a] }
          else
            args = args.collect { |i| /^[0-9]+$/ =~ i ? i.to_i : i }
          end
          self.instance( args ).divider( div )
        end

constraint_to_lambda( constraint, &yld )

Parses a constraint returning the operation as a lambda.

[Source]

    # File lib/more/facets/tuple.rb, line 263
        def constraint_to_lambda( constraint, &yld )
          op, val = *parse_constraint( constraint, &yld )
          lambda { |t| t.send(op, val) }
        end

multiton_id(arg=0, default=0, &block)

[Source]

    # File lib/more/facets/tuple.rb, line 83
      def self.multiton_id(arg=0, default=0, &block)
        if block_given?
          values = []
          arg.times { |i| values << block[i] }
        elseif Integer === arg
          values = [ default ] * arg
        else
          values = arg.to_ary
        end
        values
      end

new(arg=0, default=0, &blk)

[Source]

    # File lib/more/facets/tuple.rb, line 95
      def initialize(arg=0, default=0, &blk)
        if block_given?
          @values = []
          arg.times { |i| @values << blk[i] }
        elseif Integer === arg
          @values = [ default ] * arg
        else
          @values = arg.to_ary
        end
        @default = default
        @divider = '.'
      end

parse_constraint( constraint, &yld )

[Source]

    # File lib/more/facets/tuple.rb, line 268
        def parse_constraint( constraint, &yld )
          constraint = constraint.strip
          re = %r{^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\d+)*)$}
          if md = re.match( constraint )
            if op = md[1]
              op = '=~' if op == '~>'
              op = '==' if op == '='
              val = cast_from_string( md[2], &yld ) #instance( md[2] )
            else
              op = '=='
              val = cast_from_string( constraint, &yld ) #instance( constraint )
            end
          else
            raise ArgumentError, "invalid constraint"
          end
          return op, val
        end

### Public Instance methods

<<( obj )

Unlike Array, Tuple#<< cannot act in place becuase Tuple‘s are immutable.

[Source]

    # File lib/more/facets/tuple.rb, line 164
      def <<( obj )
        self.class.instance( to_a << obj )
      end

<=>( other )

[Source]

    # File lib/more/facets/tuple.rb, line 190
      def <=>( other )
        other = other.to_t
        [size, other.size].max.times do |i|
          c = self[i] <=> other[i]
          return c if c != 0
        end
        0
      end

=~( other )

For pessimistic constraint (like ’~>’ in gems)

[Source]

    # File lib/more/facets/tuple.rb, line 200
      def =~( other )
        other = other.to_t
        upver = other.dup
        upver[0] += 1
        self >= other and self < upver
      end

[](i)

[Source]

    # File lib/more/facets/tuple.rb, line 151
      def [](i)
        @values.fetch(i,@default)
      end

[]=(i,v)

[Source]

    # File lib/more/facets/tuple.rb, line 155
      def []=(i,v)
        @values[i] = v
      end

divider( set=nil )

[Source]

    # File lib/more/facets/tuple.rb, line 110
      def divider( set=nil )
        return @divider unless set
        @divider = set
        self
      end

each( &block )

[Source]

    # File lib/more/facets/tuple.rb, line 143
      def each( &block )
        @values.each( &block )
      end

each_index( &block )

[Source]

    # File lib/more/facets/tuple.rb, line 147
      def each_index( &block )
        @values.each_index( &block )
      end

empty?()

[Source]

    # File lib/more/facets/tuple.rb, line 137
      def empty?()
        return true if @values.empty?
        return true if @values == [ @default ] * @values.size
        false
      end

eql?( other )

Returns true if two tuple references are for the very same tuple.

[Source]

    # File lib/more/facets/tuple.rb, line 185
      def eql?( other )
        return true if object_id == other.object_id
        #return true if values.eql? other.values
      end

first()

[Source]

    # File lib/more/facets/tuple.rb, line 207
      def first() @values.first end

hash()

Unique hash value.

[Source]

    # File lib/more/facets/tuple.rb, line 216
      def hash
        # TODO This needs to take into account the default
        #      and maybe the divider too.
        to_a.hash
      end

index()

[Source]

    # File lib/more/facets/tuple.rb, line 159
      def index()  @values.index end

inspect()

[Source]

    # File lib/more/facets/tuple.rb, line 122
      def inspect() to_a.inspect end

last()

[Source]

    # File lib/more/facets/tuple.rb, line 208
      def last()  @values.last end

length()

[Source]

    # File lib/more/facets/tuple.rb, line 135
      def length() @values.size end

major()

These are useful for using a Tuple as a version.

[Source]

    # File lib/more/facets/tuple.rb, line 211
      def major() @values.first end

minor()

[Source]

    # File lib/more/facets/tuple.rb, line 212
      def minor() @values.at(1) end

pop()

[Source]

    # File lib/more/facets/tuple.rb, line 168
      def pop() Tuple.instance( to_a.pop ) end

pot( obj )

Stands for "Put On Top". This method is the opposite of pull and is otherwise known as unshift.

[Source]

    # File lib/more/facets/tuple.rb, line 178
      def pot( obj ) Tuple.instance( to_a.unshift(obj) ) end

pull()

Pulls a value off the beginning of a tuple. This method is otherwsie known as shift.

[Source]

    # File lib/more/facets/tuple.rb, line 174
      def pull() Tuple.instance( to_a.shift ) end

push( obj )

[Source]

    # File lib/more/facets/tuple.rb, line 170
      def push( obj ) Tuple.instance( to_a.push(obj) ) end

rindex()

[Source]

    # File lib/more/facets/tuple.rb, line 160
      def rindex() @values.rindex end

shift()

Alias for pull

size()

[Source]

    # File lib/more/facets/tuple.rb, line 134
      def size()   @values.size end

teeny()

[Source]

    # File lib/more/facets/tuple.rb, line 213
      def teeny() @values.at(2) end

to_a()

[Source]

    # File lib/more/facets/tuple.rb, line 127
      def to_a()   Array(@values) end

to_ary()

[Source]

    # File lib/more/facets/tuple.rb, line 128
      def to_ary() Array(@values) end

to_s( divider=nil )

[Source]

    # File lib/more/facets/tuple.rb, line 130
      def to_s( divider=nil )
        @values.join(divider||@divider)
      end

to_t()

[Source]

    # File lib/more/facets/tuple.rb, line 124
      def to_t()     self end

to_tuple()

[Source]

    # File lib/more/facets/tuple.rb, line 125
      def to_tuple() self end

unshift( obj )

Alias for pot

### Protected Instance methods

values()

[Source]

    # File lib/more/facets/tuple.rb, line 118
      def values() @values end

[Validate]