| 
 | 
          Scala 1.3.0.7 | |||
Map
  functions of the class into which it is mixed in.
  | Method Summary | |
| 
        override | def ++=(map: Iterable[Tuple2[A,B]]): UnitThis method adds all the mappings provided by an iterator of parameter mapto the map. | 
| 
        override | def ++=(it: Iterator[Tuple2[A,B]]): UnitThis method adds all the mappings provided by an iterator of parameter mapto the map. | 
| 
        override | def --=(keys: Iterable[A]): UnitThis method removes all the mappings for keys provided by an iterator over the elements of the keysobject. | 
| 
        override | def --=(it: Iterator[A]): UnitThis method removes all the mappings for keys provided by an iterator over the elements of the keysobject. | 
| 
        override | def -=(key: A): UnitThis method removes a mapping from the given key. | 
| 
        override | def <<(cmd: Message[Tuple2[A,B]]): UnitSend a message to this scriptable object. | 
| 
        override | def apply(key: A): BRetrieve the value which is associated with the given key. | 
| 
        override | def clear: UnitRemoves all mappings from the map. | 
| 
        override | def clone(): Map[A,B]Return a clone of this map. | 
| 
        override | def contains(key: A): BooleanIs the given key mapped to a value by this map? | 
| 
        override | def excl(keys: A*): UnitThis method will remove all the mappings for the given sequence of keys from the map. | 
| 
        override | def filter(p: (A,B) => Boolean): UnitThis method removes all the mappings for which the predicate preturnsfalse. | 
| 
        override | def foreach(f: (A,B) => Unit): UnitExecutes the given function for all (key, value) pairs contained in this map. | 
| def foreach(f: (A) => Unit): UnitApply a function fto all elements of this
  iterable object. | |
| 
        override | def get(key: A): Option[B]Check if this map maps keyto a value and return the
  value if it exists. | 
| 
        override | def incl(mappings: Tuple2[A,B]*): Unitinclcan be used to add many mappings at the same time
  to the map. | 
| 
        override | def isDefinedAt(key: A): BooleanDoes this map contain a mapping from the given key to a value? | 
| 
        override | def isEmpty: BooleanIs this an empty map? | 
| 
        override | def keys: Iterator[A]Creates an iterator for all keys. | 
| 
        override | def map(f: (A,B) => B): UnitThis function transforms all the values of mappings contained in this map with function f. | 
| 
        override | def size: IntCompute the number of key-to-value mappings. | 
| 
        override | def toList: List[Tuple2[A,B]]Returns the mappings of this map as a list. | 
| 
        override | def toString(): StringReturns a string representation of this map which shows all the mappings. | 
| 
        override | def update(key: A, value: B): UnitThis method allows one to add a new mapping from keytovalueto the map. | 
| 
        override | def values: Iterator[B]Creates an iterator for a contained values. | 
| Methods inherited from java/lang/Object-class | 
| eq, finalize, getClass, notify, notifyAll, synchronized, wait, wait, wait | 
| Methods inherited from scala/Any-class | 
| !=, ==, asInstanceOf, isInstanceOf, match | 
| Methods inherited from scala/Iterable-class | 
| /:, :\, elements, exists, find, foldLeft, foldRight, forall, foreach, sameElements | 
| Methods inherited from scala/ScalaObject-class | 
| getType | 
| Methods inherited from scala/collection/Map-class | 
| equals, exists, forall | 
| Methods inherited from scala/collection/mutable/Map-class | 
| +=, hashCode, mappingToString | 
| Method Detail | 
override def size: Int
override def get(key: A): Option[B]
key to a value and return the
  value if it exists.
key - 
  the key of the mapping of interest
  override def isEmpty: Boolean
override def apply(key: A): B
key - 
  the key
  override def contains(key: A): Boolean
key - 
  the key
  override def isDefinedAt(key: A): Boolean
key - 
  the key
  override def keys: Iterator[A]
override def values: Iterator[B]
override def foreach(f: (A,B) => Unit): Unit
f - 
  the function to execute.
     
  def foreach(f: (A) => Unit): Unit
f to all elements of this
  iterable object.
f - 
  a function that is applied to every element.
     
  override def toList: List[Tuple2[A,B]]
override def update(key: A, value: B): Unit
key
  to value to the map. If the map already contains a
  mapping for key, it will be overridden by this
  function.
     
override def ++=(map: Iterable[Tuple2[A,B]]): Unit
map to the map.
     
override def ++=(it: Iterator[Tuple2[A,B]]): Unit
map to the map.
     
override def incl(mappings: Tuple2[A,B]*): Unit
incl can be used to add many mappings at the same time
  to the map. The method assumes that a mapping is represented
  by a Pair object who's first component denotes the
  key, and who's second component refers to the value.
     
override def -=(key: A): Unit
key.
  If the map does not contain a mapping for the given key, the
  method does nothing.
     
override def --=(keys: Iterable[A]): Unit
keys object.
     
override def --=(it: Iterator[A]): Unit
keys object.
     
override def excl(keys: A*): Unit
override def clear: Unit
override def map(f: (A,B) => B): Unit
f.
     
override def filter(p: (A,B) => Boolean): Unit
p returns false.
     
override def toString(): String
override def <<(cmd: Message[Tuple2[A,B]]): Unit
cmd - 
  the message to send.
     
  override def clone(): Map[A,B]
| 
 | 
          Scala 1.3.0.7 | |||