trait RandomAccessSeq in scala

override def projection : Projection[A]

returns a projection that can be used to call non-strict filter, map, and flatMap methods that build projections of the collection.

Overrides: Seq.projection

override def elements : Iterator[A]

Creates a new iterator over all elements contained in this object.

Returns: the new iterator

override def drop(from : Int) : RandomAccessSeq[A]

Returns this sequence without its n first elements If this sequence has less than n elements, the empty sequence is returned. (non-strict)

Parameters: n - the number of elements to drop
Returns: the new sequence

Overrides: Seq.drop

override def take(until : Int) : RandomAccessSeq[A]

Returns a sequence consisting only over the first n elements of this sequence, or else the whole sequence, if it has less than n elements. (non-strict)

Parameters: n - the number of elements to take
Returns: a possibly projected sequence

Overrides: Seq.take

override def slice(from0 : Int, until0 : Int) : RandomAccessSeq[A]

A sub-sequence starting at index from and ending (non-inclusive) at index until (non-strict)

Parameters: from - The index of the first element of the slice; until - The index of the element following the slice
Throws: IndexOutOfBoundsException - if from < 0 or length < from + len


    
        
          Overrides
        
        
        Seq.slice
        
      


      
        
        override
        def
        reverse : Seq[A]
      
      
    
      A sequence consisting of all elements of this sequence in reverse order.
      
    
        
          Overrides
        
        
        Seq.reverse
        
      


      
        
        override
        def
        partition(p : (A) => Boolean) : (RandomAccessSeq[A], RandomAccessSeq[A])
      
      
    
      Partitions this random access sequence in two random access
    sequences according to a predicate.
      
        Parameters
p - the predicate on which to partition

        Returns
a pair of random access sequences: the sequence of all elements             that satisfy the predicate p and the sequence of
             all elements that do not.
             The relative order of the elements in the resulting sequences
             is the same as in the original sequence.
    

      
        
        
        def
        patch[B >: A](from0 : Int, patch0 : RandomAccessSeq[B], replaced0 : Int) : Projection[B]
      
      
    
      insert segment patch into this sequence at from  
    replacing  replaced elements. The result is a projection.
      
    

      
        
        override
        def
        ++[B >: A](that : Iterable[B]) : RandomAccessSeq[B]
      
      
    
      Appends two iterable objects.
      
    
        
          Overrides
        
        
        Seq.++
        
      


      
        
        override
        def
        toStream : Stream[A]
      
      
    
      Returns a stream containing all of the elements in this iterable object.
      
        Notes
consider using projection for lazy behavior.
    

      
        
        final
        def
        safeIs(idx : Int, a : Any) : Boolean
      
      
    
      will return false if index is out of bounds

Method Summary
`override def`	++ [B >: A](that : Iterable[B]) : RandomAccessSeq[B] Appends two iterable objects.
`override def`	drop (from : Int) : RandomAccessSeq[A] Returns this sequence without its `n` first elements If this sequence has less than `n` elements, the empty sequence is returned. (non-strict)
`override def`	elements : Iterator[A] Creates a new iterator over all elements contained in this object.
`override def`	partition (p : (A) => Boolean) : (RandomAccessSeq[A], RandomAccessSeq[A]) Partitions this random access sequence in two random access sequences according to a predicate.
`def`	patch [B >: A](from0 : Int, patch0 : RandomAccessSeq[B], replaced0 : Int) : Projection[B] insert segment `patch` into this sequence at `from` replacing `replaced` elements. The result is a projection.
`override def`	projection : Projection[A] returns a projection that can be used to call non-strict `filter`, `map`, and `flatMap` methods that build projections of the collection.
`override def`	reverse : Seq[A] A sequence consisting of all elements of this sequence in reverse order.
`final def`	safeIs (idx : Int, a : Any) : Boolean will return false if index is out of bounds
`override def`	slice (from0 : Int, until0 : Int) : RandomAccessSeq[A] A sub-sequence starting at index `from` and ending (non-inclusive) at index `until` (non-strict)
`override def`	take (until : Int) : RandomAccessSeq[A] Returns a sequence consisting only over the first `n` elements of this sequence, or else the whole sequence, if it has less than `n` elements. (non-strict)
`override def`	toStream : Stream[A] Returns a stream containing all of the elements in this iterable object.

Methods inherited from Seq
length (abstract), lengthCompare, size, isEmpty, concat, last, lastOption, first, firstOption, headOption, isDefinedAt, lastIndexOf, findIndexOf, indexOf, map, flatMap, filter, slice, takeWhile, dropWhile, contains, subseq, toArray, toSeq, equalsWith, startsWith, startsWith, endsWith, indexOf, containsSlice

Methods inherited from Iterable
foreach, forall, exists, find, foldLeft, foldRight, /:, :\, reduceLeft, reduceRight, copyToBuffer, sameElements, toList, mkString, mkString, mkString, addString, addString, addString, copyToArray, hasDefiniteSize

Methods inherited from AnyRef
getClass, hashCode, equals, clone, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

	Scala Library

Methods inherited from Collection
toString, stringPrefix

Methods inherited from PartialFunction
orElse, andThen

	Scala Library