1 files changed, 765 insertions, 0 deletions
diff --git a/imports/codemirror/mode/clike/scala.html b/imports/codemirror/mode/clike/scala.html
new file mode 100644
index 00000000..5fdd84ed
--- /dev/null
+++ b/imports/codemirror/mode/clike/scala.html
@@ -0,0 +1,765 @@
+<!doctype html>
+<html>
+  <head>
+    <title>CodeMirror: C-like mode</title>
+    <link rel="stylesheet" href="../../lib/codemirror.css">
+    <link rel="stylesheet" href="../../theme/ambiance.css">
+    <script src="../../lib/codemirror.js"></script>
+    <script src="clike.js"></script>
+    <link rel="stylesheet" href="../../doc/docs.css">
+    <style>
+      body
+      {
+        margin: 0;
+        padding: 0;
+        max-width:inherit;
+        height: 100%;
+      }
+      html, form, .CodeMirror, .CodeMirror-scroll
+      {
+        height: 100%;        
+      }
+    </style>
+  </head>
+  <body>
+<form>
+<textarea id="code" name="code">
+  /*                     __                                               *\
+  **     ________ ___   / /  ___     Scala API                            **
+  **    / __/ __// _ | / /  / _ |    (c) 2003-2011, LAMP/EPFL             **
+  **  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+  ** /____/\___/_/ |_/____/_/ | |                                         **
+  **                          |/                                          **
+  \*                                                                      */
+  package scala.collection
+  import generic._
+  import mutable.{ Builder, ListBuffer }
+  import annotation.{tailrec, migration, bridge}
+  import annotation.unchecked.{ uncheckedVariance => uV }
+  import parallel.ParIterable
+  /** A template trait for traversable collections of type `Traversable[A]`.
+   *  
+   *  $traversableInfo
+   *  @define mutability
+   *  @define traversableInfo
+   *  This is a base trait of all kinds of $mutability Scala collections. It
+   *  implements the behavior common to all collections, in terms of a method
+   *  `foreach` with signature:
+   * {{{
+   *     def foreach[U](f: Elem => U): Unit
+   * }}}
+   *  Collection classes mixing in this trait provide a concrete 
+   *  `foreach` method which traverses all the
+   *  elements contained in the collection, applying a given function to each.
+   *  They also need to provide a method `newBuilder`
+   *  which creates a builder for collections of the same kind.
+   *  
+   *  A traversable class might or might not have two properties: strictness
+   *  and orderedness. Neither is represented as a type.
+   *  
+   *  The instances of a strict collection class have all their elements
+   *  computed before they can be used as values. By contrast, instances of
+   *  a non-strict collection class may defer computation of some of their
+   *  elements until after the instance is available as a value.
+   *  A typical example of a non-strict collection class is a
+   *  <a href="../immutable/Stream.html" target="ContentFrame">
+   *  `scala.collection.immutable.Stream`</a>.
+   *  A more general class of examples are `TraversableViews`.
+   *  
+   *  If a collection is an instance of an ordered collection class, traversing
+   *  its elements with `foreach` will always visit elements in the
+   *  same order, even for different runs of the program. If the class is not
+   *  ordered, `foreach` can visit elements in different orders for
+   *  different runs (but it will keep the same order in the same run).'
+   * 
+   *  A typical example of a collection class which is not ordered is a
+   *  `HashMap` of objects. The traversal order for hash maps will
+   *  depend on the hash codes of its elements, and these hash codes might
+   *  differ from one run to the next. By contrast, a `LinkedHashMap`
+   *  is ordered because it's `foreach` method visits elements in the
+   *  order they were inserted into the `HashMap`.
+   *
+   *  @author Martin Odersky
+   *  @version 2.8
+   *  @since   2.8
+   *  @tparam A    the element type of the collection
+   *  @tparam Repr the type of the actual collection containing the elements.
+   *
+   *  @define Coll Traversable
+   *  @define coll traversable collection
+   */
+  trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr] 
+                                      with FilterMonadic[A, Repr]
+                                      with TraversableOnce[A]
+                                      with GenTraversableLike[A, Repr]
+                                      with Parallelizable[A, ParIterable[A]]
+  {
+    self =>
+    import Traversable.breaks._
+    /** The type implementing this traversable */
+    protected type Self = Repr
+    /** The collection of type $coll underlying this `TraversableLike` object.
+     *  By default this is implemented as the `TraversableLike` object itself,
+     *  but this can be overridden.
+     */
+    def repr: Repr = this.asInstanceOf[Repr]
+    /** The underlying collection seen as an instance of `$Coll`.
+     *  By default this is implemented as the current collection object itself,
+     *  but this can be overridden.
+     */
+    protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]]
+    /** A conversion from collections of type `Repr` to `$Coll` objects.
+     *  By default this is implemented as just a cast, but this can be overridden.
+     */
+    protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]]
+    /** Creates a new builder for this collection type.
+     */
+    protected[this] def newBuilder: Builder[A, Repr]
+    protected[this] def parCombiner = ParIterable.newCombiner[A]
+    /** Applies a function `f` to all elements of this $coll.
+     *  
+     *    Note: this method underlies the implementation of most other bulk operations.
+     *    It's important to implement this method in an efficient way.
+     *  
+     *
+     *  @param  f   the function that is applied for its side-effect to every element.
+     *              The result of function `f` is discarded.
+     *              
+     *  @tparam  U  the type parameter describing the result of function `f`. 
+     *              This result will always be ignored. Typically `U` is `Unit`,
+     *              but this is not necessary.
+     *
+     *  @usecase def foreach(f: A => Unit): Unit
+     */
+    def foreach[U](f: A => U): Unit
+    /** Tests whether this $coll is empty.
+     *
+     *  @return    `true` if the $coll contain no elements, `false` otherwise.
+     */
+    def isEmpty: Boolean = {
+      var result = true
+      breakable {
+        for (x <- this) {
+          result = false
+          break
+        }
+      }
+      result
+    }
+    /** Tests whether this $coll is known to have a finite size.
+     *  All strict collections are known to have finite size. For a non-strict collection
+     *  such as `Stream`, the predicate returns `true` if all elements have been computed.
+     *  It returns `false` if the stream is not yet evaluated to the end.
+     *
+     *  Note: many collection methods will not work on collections of infinite sizes. 
+     *
+     *  @return  `true` if this collection is known to have finite size, `false` otherwise.
+     */
+    def hasDefiniteSize = true
+    def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+      val b = bf(repr)
+      if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
+      b ++= thisCollection
+      b ++= that.seq
+      b.result
+    }
+    @bridge
+    def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
+      ++(that: GenTraversableOnce[B])(bf)
+    /** Concatenates this $coll with the elements of a traversable collection.
+     *  It differs from ++ in that the right operand determines the type of the
+     *  resulting collection rather than the left one.
+     * 
+     *  @param that   the traversable to append.
+     *  @tparam B     the element type of the returned collection. 
+     *  @tparam That  $thatinfo
+     *  @param bf     $bfinfo
+     *  @return       a new collection of type `That` which contains all elements
+     *                of this $coll followed by all elements of `that`.
+     * 
+     *  @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]
+     *  
+     *  @return       a new $coll which contains all elements of this $coll
+     *                followed by all elements of `that`.
+     */
+    def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+      val b = bf(repr)
+      if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
+      b ++= that
+      b ++= thisCollection
+      b.result
+    }
+    /** This overload exists because: for the implementation of ++: we should reuse
+     *  that of ++ because many collections override it with more efficient versions.
+     *  Since TraversableOnce has no '++' method, we have to implement that directly,
+     *  but Traversable and down can use the overload.
+     */
+    def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
+      (that ++ seq)(breakOut)
+    def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
+      val b = bf(repr)
+      b.sizeHint(this) 
+      for (x <- this) b += f(x)
+      b.result
+    }

diff --git a/imports/codemirror/mode/clike/scala.html b/imports/codemirror/mode/clike/scala.html new file mode 100644 index 00000000..5fdd84ed --- /dev/null +++ b/imports/codemirror/mode/clike/scala.html
@@ -0,0 +1,765 @@
	1	<!doctype html>
	2	<html>
	3	<head>
	4	<title>CodeMirror: C-like mode</title>
	5	<link rel="stylesheet" href="../../lib/codemirror.css">
	6	<link rel="stylesheet" href="../../theme/ambiance.css">
	7	<script src="../../lib/codemirror.js"></script>
	8	<script src="clike.js"></script>
	9	<link rel="stylesheet" href="../../doc/docs.css">
	10	<style>
	11	body
	12	{
	13	margin: 0;
	14	padding: 0;
	15	max-width:inherit;
	16	height: 100%;
	17	}
	18	html, form, .CodeMirror, .CodeMirror-scroll
	19	{
	20	height: 100%;
	21	}
	22	</style>
	23	</head>
	24	<body>
	25	<form>
	26	<textarea id="code" name="code">
	27
	28	/* __ *\
	29	________ ___ / / ___ Scala API
	30	/ __/ __// _ \| / / / _ \| (c) 2003-2011, LAMP/EPFL
	31	__\ \/ /__/ __ \|/ /__/ __ \| http://scala-lang.org/
	32	/____/\___/_/ \|_/____/_/ \| \|
	33	\|/
	34	\* */
	35
	36	package scala.collection
	37
	38	import generic._
	39	import mutable.{ Builder, ListBuffer }
	40	import annotation.{tailrec, migration, bridge}
	41	import annotation.unchecked.{ uncheckedVariance => uV }
	42	import parallel.ParIterable
	43
	44	/** A template trait for traversable collections of type `Traversable[A]`.
	45	*
	46	* $traversableInfo
	47	* @define mutability
	48	* @define traversableInfo
	49	* This is a base trait of all kinds of $mutability Scala collections. It
	50	* implements the behavior common to all collections, in terms of a method
	51	* `foreach` with signature:
	52	* {{{
	53	* def foreach[U](f: Elem => U): Unit
	54	* }}}
	55	* Collection classes mixing in this trait provide a concrete
	56	* `foreach` method which traverses all the
	57	* elements contained in the collection, applying a given function to each.
	58	* They also need to provide a method `newBuilder`
	59	* which creates a builder for collections of the same kind.
	60	*
	61	* A traversable class might or might not have two properties: strictness
	62	* and orderedness. Neither is represented as a type.
	63	*
	64	* The instances of a strict collection class have all their elements
	65	* computed before they can be used as values. By contrast, instances of
	66	* a non-strict collection class may defer computation of some of their
	67	* elements until after the instance is available as a value.
	68	* A typical example of a non-strict collection class is a
	69	* <a href="../immutable/Stream.html" target="ContentFrame">
	70	* `scala.collection.immutable.Stream`</a>.
	71	* A more general class of examples are `TraversableViews`.
	72	*
	73	* If a collection is an instance of an ordered collection class, traversing
	74	* its elements with `foreach` will always visit elements in the
	75	* same order, even for different runs of the program. If the class is not
	76	* ordered, `foreach` can visit elements in different orders for
	77	* different runs (but it will keep the same order in the same run).'
	78	*
	79	* A typical example of a collection class which is not ordered is a
	80	* `HashMap` of objects. The traversal order for hash maps will
	81	* depend on the hash codes of its elements, and these hash codes might
	82	* differ from one run to the next. By contrast, a `LinkedHashMap`
	83	* is ordered because it's `foreach` method visits elements in the
	84	* order they were inserted into the `HashMap`.
	85	*
	86	* @author Martin Odersky
	87	* @version 2.8
	88	* @since 2.8
	89	* @tparam A the element type of the collection
	90	* @tparam Repr the type of the actual collection containing the elements.
	91	*
	92	* @define Coll Traversable
	93	* @define coll traversable collection
	94	*/
	95	trait TraversableLike[+A, +Repr] extends HasNewBuilder[A, Repr]
	96	with FilterMonadic[A, Repr]
	97	with TraversableOnce[A]
	98	with GenTraversableLike[A, Repr]
	99	with Parallelizable[A, ParIterable[A]]
	100	{
	101	self =>
	102
	103	import Traversable.breaks._
	104
	105	/** The type implementing this traversable */
	106	protected type Self = Repr
	107
	108	/** The collection of type $coll underlying this `TraversableLike` object.
	109	* By default this is implemented as the `TraversableLike` object itself,
	110	* but this can be overridden.
	111	*/
	112	def repr: Repr = this.asInstanceOf[Repr]
	113
	114	/** The underlying collection seen as an instance of `$Coll`.
	115	* By default this is implemented as the current collection object itself,
	116	* but this can be overridden.
	117	*/
	118	protected[this] def thisCollection: Traversable[A] = this.asInstanceOf[Traversable[A]]
	119
	120	/** A conversion from collections of type `Repr` to `$Coll` objects.
	121	* By default this is implemented as just a cast, but this can be overridden.
	122	*/
	123	protected[this] def toCollection(repr: Repr): Traversable[A] = repr.asInstanceOf[Traversable[A]]
	124
	125	/** Creates a new builder for this collection type.
	126	*/
	127	protected[this] def newBuilder: Builder[A, Repr]
	128
	129	protected[this] def parCombiner = ParIterable.newCombiner[A]
	130
	131	/** Applies a function `f` to all elements of this $coll.
	132	*
	133	* Note: this method underlies the implementation of most other bulk operations.
	134	* It's important to implement this method in an efficient way.
	135	*
	136	*
	137	* @param f the function that is applied for its side-effect to every element.
	138	* The result of function `f` is discarded.
	139	*
	140	* @tparam U the type parameter describing the result of function `f`.
	141	* This result will always be ignored. Typically `U` is `Unit`,
	142	* but this is not necessary.
	143	*
	144	* @usecase def foreach(f: A => Unit): Unit
	145	*/
	146	def foreach[U](f: A => U): Unit
	147
	148	/** Tests whether this $coll is empty.
	149	*
	150	* @return `true` if the $coll contain no elements, `false` otherwise.
	151	*/
	152	def isEmpty: Boolean = {
	153	var result = true
	154	breakable {
	155	for (x <- this) {
	156	result = false
	157	break
	158	}
	159	}
	160	result
	161	}
	162
	163	/** Tests whether this $coll is known to have a finite size.
	164	* All strict collections are known to have finite size. For a non-strict collection
	165	* such as `Stream`, the predicate returns `true` if all elements have been computed.
	166	* It returns `false` if the stream is not yet evaluated to the end.
	167	*
	168	* Note: many collection methods will not work on collections of infinite sizes.
	169	*
	170	* @return `true` if this collection is known to have finite size, `false` otherwise.
	171	*/
	172	def hasDefiniteSize = true
	173
	174	def ++[B >: A, That](that: GenTraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
	175	val b = bf(repr)
	176	if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.seq.size)
	177	b ++= thisCollection
	178	b ++= that.seq
	179	b.result
	180	}
	181
	182	@bridge
	183	def ++[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
	184	++(that: GenTraversableOnce[B])(bf)
	185
	186	/** Concatenates this $coll with the elements of a traversable collection.
	187	* It differs from ++ in that the right operand determines the type of the
	188	* resulting collection rather than the left one.
	189	*
	190	* @param that the traversable to append.
	191	* @tparam B the element type of the returned collection.
	192	* @tparam That $thatinfo
	193	* @param bf $bfinfo
	194	* @return a new collection of type `That` which contains all elements
	195	* of this $coll followed by all elements of `that`.
	196	*
	197	* @usecase def ++:[B](that: TraversableOnce[B]): $Coll[B]
	198	*
	199	* @return a new $coll which contains all elements of this $coll
	200	* followed by all elements of `that`.
	201	*/
	202	def ++:[B >: A, That](that: TraversableOnce[B])(implicit bf: CanBuildFrom[Repr, B, That]): That = {
	203	val b = bf(repr)
	204	if (that.isInstanceOf[IndexedSeqLike[_, _]]) b.sizeHint(this, that.size)
	205	b ++= that
	206	b ++= thisCollection
	207	b.result
	208	}
	209
	210	/** This overload exists because: for the implementation of ++: we should reuse
	211	* that of ++ because many collections override it with more efficient versions.
	212	* Since TraversableOnce has no '++' method, we have to implement that directly,
	213	* but Traversable and down can use the overload.
	214	*/
	215	def ++:[B >: A, That](that: Traversable[B])(implicit bf: CanBuildFrom[Repr, B, That]): That =
	216	(that ++ seq)(breakOut)
	217
	218	def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That = {
	219	val b = bf(repr)
	220	b.sizeHint(this)
	221	for (x <- this) b += f(x)
	222	b.result
	223	}