From fd1ca1e63c876046936f681be26730a301da8ff2 Mon Sep 17 00:00:00 2001 From: Paul Phillips Date: Sun, 20 Feb 2011 06:51:57 +0000 Subject: Moved unlift to the Function companion object, ... Moved unlift to the Function companion object, which might have been better in the first place. Had to make a minor change to genprod, and then I couldn't escape that unscathed. Finished the not very complete undertaking I found there to update the scaladoc. Lots of little changes to the generated text and code. I changed genprod to only put a unique stamp on Function0 so we can stop having a 100 file diff everytime an i is dotted somewhere. Closes #3825, no review. --- src/library/scala/Function.scala | 19 +++- src/library/scala/Function0.scala | 28 +++-- src/library/scala/Function1.scala | 52 ++++----- src/library/scala/Function10.scala | 24 ++-- src/library/scala/Function11.scala | 24 ++-- src/library/scala/Function12.scala | 24 ++-- src/library/scala/Function13.scala | 24 ++-- src/library/scala/Function14.scala | 24 ++-- src/library/scala/Function15.scala | 24 ++-- src/library/scala/Function16.scala | 24 ++-- src/library/scala/Function17.scala | 24 ++-- src/library/scala/Function18.scala | 24 ++-- src/library/scala/Function19.scala | 24 ++-- src/library/scala/Function2.scala | 33 +++--- src/library/scala/Function20.scala | 24 ++-- src/library/scala/Function21.scala | 24 ++-- src/library/scala/Function22.scala | 24 ++-- src/library/scala/Function3.scala | 24 ++-- src/library/scala/Function4.scala | 24 ++-- src/library/scala/Function5.scala | 24 ++-- src/library/scala/Function6.scala | 24 ++-- src/library/scala/Function7.scala | 24 ++-- src/library/scala/Function8.scala | 24 ++-- src/library/scala/Function9.scala | 24 ++-- src/library/scala/PartialFunction.scala | 4 +- src/library/scala/Product1.scala | 21 ++-- src/library/scala/Product10.scala | 66 ++++++----- src/library/scala/Product11.scala | 71 ++++++------ src/library/scala/Product12.scala | 76 +++++++------ src/library/scala/Product13.scala | 81 +++++++------ src/library/scala/Product14.scala | 86 +++++++------- src/library/scala/Product15.scala | 91 ++++++++------- src/library/scala/Product16.scala | 96 +++++++++------- src/library/scala/Product17.scala | 101 +++++++++-------- src/library/scala/Product18.scala | 106 +++++++++-------- src/library/scala/Product19.scala | 111 ++++++++++-------- src/library/scala/Product2.scala | 26 ++--- src/library/scala/Product20.scala | 116 ++++++++++--------- src/library/scala/Product21.scala | 121 +++++++++++--------- src/library/scala/Product22.scala | 126 ++++++++++++--------- src/library/scala/Product3.scala | 31 +++-- src/library/scala/Product4.scala | 36 +++--- src/library/scala/Product5.scala | 41 ++++--- src/library/scala/Product6.scala | 46 ++++---- src/library/scala/Product7.scala | 51 +++++---- src/library/scala/Product8.scala | 56 ++++----- src/library/scala/Product9.scala | 61 +++++----- src/library/scala/Tuple1.scala | 11 +- src/library/scala/Tuple10.scala | 20 +++- src/library/scala/Tuple11.scala | 21 +++- src/library/scala/Tuple12.scala | 22 +++- src/library/scala/Tuple13.scala | 23 +++- src/library/scala/Tuple14.scala | 24 +++- src/library/scala/Tuple15.scala | 25 +++- src/library/scala/Tuple16.scala | 26 ++++- src/library/scala/Tuple17.scala | 27 ++++- src/library/scala/Tuple18.scala | 28 ++++- src/library/scala/Tuple19.scala | 29 ++++- src/library/scala/Tuple2.scala | 28 +++-- src/library/scala/Tuple20.scala | 30 ++++- src/library/scala/Tuple21.scala | 31 ++++- src/library/scala/Tuple22.scala | 32 +++++- src/library/scala/Tuple3.scala | 24 ++-- src/library/scala/Tuple4.scala | 14 ++- src/library/scala/Tuple5.scala | 15 ++- src/library/scala/Tuple6.scala | 16 ++- src/library/scala/Tuple7.scala | 17 ++- src/library/scala/Tuple8.scala | 18 ++- src/library/scala/Tuple9.scala | 19 +++- src/library/scala/runtime/AbstractFunction0.scala | 5 +- src/library/scala/runtime/AbstractFunction1.scala | 5 +- src/library/scala/runtime/AbstractFunction10.scala | 5 +- src/library/scala/runtime/AbstractFunction11.scala | 5 +- src/library/scala/runtime/AbstractFunction12.scala | 5 +- src/library/scala/runtime/AbstractFunction13.scala | 5 +- src/library/scala/runtime/AbstractFunction14.scala | 5 +- src/library/scala/runtime/AbstractFunction15.scala | 5 +- src/library/scala/runtime/AbstractFunction16.scala | 5 +- src/library/scala/runtime/AbstractFunction17.scala | 5 +- src/library/scala/runtime/AbstractFunction18.scala | 5 +- src/library/scala/runtime/AbstractFunction19.scala | 5 +- src/library/scala/runtime/AbstractFunction2.scala | 5 +- src/library/scala/runtime/AbstractFunction20.scala | 5 +- src/library/scala/runtime/AbstractFunction21.scala | 5 +- src/library/scala/runtime/AbstractFunction22.scala | 5 +- src/library/scala/runtime/AbstractFunction3.scala | 5 +- src/library/scala/runtime/AbstractFunction4.scala | 5 +- src/library/scala/runtime/AbstractFunction5.scala | 5 +- src/library/scala/runtime/AbstractFunction6.scala | 5 +- src/library/scala/runtime/AbstractFunction7.scala | 5 +- src/library/scala/runtime/AbstractFunction8.scala | 5 +- src/library/scala/runtime/AbstractFunction9.scala | 5 +- 92 files changed, 1605 insertions(+), 1243 deletions(-) (limited to 'src/library') diff --git a/src/library/scala/Function.scala b/src/library/scala/Function.scala index cfdfa009ce..ff0769b84b 100644 --- a/src/library/scala/Function.scala +++ b/src/library/scala/Function.scala @@ -15,8 +15,7 @@ package scala * @author Martin Odersky * @version 1.0, 29/11/2006 */ -object Function -{ +object Function { /** Given a sequence of functions f1, ..., * fn, return the function f1 * andThen ... andThen fn. @@ -29,6 +28,22 @@ object Function /** The constant function */ def const[T, U](x: T)(y: U): T = x + /** Turns a function `A => Option[B]` into a `PartialFunction[A, B]`. Important note: + * this transformation implies the original function will be called 2 or more + * times on each logical invocation, because the only way to supply an implementation + * of isDefinedAt is to call the function and examine the return value. + * + * @param f a function T => Option[R] + * @return a partial function defined for those inputs where + * f returns Some(_) and undefined where f returns None. + * @see PartialFunction#lift + */ + def unlift[T, R](f: T => Option[R]): PartialFunction[T, R] = new PartialFunction[T, R] { + def apply(x: T): R = f(x).get + def isDefinedAt(x: T): Boolean = f(x).isDefined + override def lift: T => Option[R] = f + } + /** Currying for functions of arity 2. This transforms a function * of arity 2 into a a unary function returning another unary function. * diff --git a/src/library/scala/Function0.scala b/src/library/scala/Function0.scala index 5fadb9ab27..d17122c0d8 100644 --- a/src/library/scala/Function0.scala +++ b/src/library/scala/Function0.scala @@ -5,35 +5,33 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with fancy comment) +// GENERATED CODE: DO NOT EDIT. +// genprod generated these sources at: Sat Feb 19 20:13:51 PST 2011 package scala - - -/** Function with 0 parameters. +/** A function of 0 parameters. * - * In the following example the definition of - * currentSeconds is a shorthand for the anonymous class - * definition anonfun0: + * In the following example, the definition of javaVersion is a + * shorthand for the anonymous class definition anonfun0: * * {{{ * object Main extends Application { - * val currentSeconds = () => System.currentTimeMillis() / 1000L + * val javaVersion = () => sys.props("java.version") * - * val anonfun0 = new Function0[Long] { - * def apply(): Long = System.currentTimeMillis() / 1000L + * val anonfun0 = new Function0[String] { + * def apply(): String = sys.props("java.version") * } - * - * println(currentSeconds()) - * println(anonfun0()) + * assert(javaVersion() == anonfun0()) * } * }}} */ trait Function0[@specialized +R] extends AnyRef { self => + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ def apply(): R - override def toString() = "" + override def toString() = "" } diff --git a/src/library/scala/Function1.scala b/src/library/scala/Function1.scala index 8fb50b49b5..e256a94961 100644 --- a/src/library/scala/Function1.scala +++ b/src/library/scala/Function1.scala @@ -5,59 +5,47 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with fancy comment) (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 1 parameter. +/** A function of 1 parameter. * - * In the following example the definition of - * succ is a shorthand for the anonymous class - * definition anonfun1: + * In the following example, the definition of succ is a + * shorthand for the anonymous class definition anonfun1: * * {{{ * object Main extends Application { * val succ = (x: Int) => x + 1 - * * val anonfun1 = new Function1[Int, Int] { * def apply(x: Int): Int = x + 1 * } - * - * println(succ(0)) - * println(anonfun1(0)) + * assert(succ(0) == anonfun1(0)) * } * }}} */ trait Function1[@specialized(scala.Int, scala.Long, scala.Float, scala.Double) -T1, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double) +R] extends AnyRef { self => - def apply(v1:T1): R - override def toString() = "" - - /** (f compose g)(x) == f(g(x)) + /** Apply the body of this function to the argument. + * @return the result of function application. */ - def compose[A](g: A => T1): A => R = { x => apply(g(x)) } + def apply(v1: T1): R - /** (f andThen g)(x) == g(f(x)) + /** Composes two instances of Function1 in a new Function1, with this function applied last. + * + * @tparam A the type to which function `g` can be applied + * @param g a function A => T1 + * @return a new function `f` such that `f(x) == apply(g(x))` */ - def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } + def compose[A](g: A => T1): A => R = { x => apply(g(x)) } - /** Turns a function A => Option[B] into a PartialFunction[A, B]. Important note: - * this transformation implies the original function will be called 2 or more - * times on each logical invocation, because the only way to supply an implementation - * of isDefinedAt is to call the function and examine the return value. + /** Composes two instances of Function1 in a new Function1, with this function applied first. * - * @see PartialFunction#lift - * @return a partial function which is defined for those inputs - * where this function returns Some(_) and undefined where - * this function returns None. + * @tparam A the result type of function `g` + * @param g a function R => A + * @return a new function `f` such that `f(x) == g(apply(x))` */ - def unlift[R1](implicit ev: R <:< Option[R1]): PartialFunction[T1, R1] = new PartialFunction[T1, R1] { - def apply(x: T1): R1 = ev(Function1.this.apply(x)).get - def isDefinedAt(x: T1): Boolean = Function1.this.apply(x).isDefined - override def lift = Function1.this.asInstanceOf[T1 => Option[R1]] - } + def andThen[A](g: R => A): T1 => A = { x => g(apply(x)) } + override def toString() = "" } diff --git a/src/library/scala/Function10.scala b/src/library/scala/Function10.scala index cb48db06ec..c4b8764d58 100644 --- a/src/library/scala/Function10.scala +++ b/src/library/scala/Function10.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 10 parameters. +/** A function of 10 parameters. * */ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)).curried @@ -28,10 +29,13 @@ trait Function10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) == (f.tupled)(Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) + /** Creates a tupled version of this function: instead of 10 arguments, + * it accepts a single [[scala.Tuple10]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) == f(Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)` */ def tupled: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] => R = { case Tuple10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) } - + override def toString() = "" } diff --git a/src/library/scala/Function11.scala b/src/library/scala/Function11.scala index 2f039c705d..48ba6e2737 100644 --- a/src/library/scala/Function11.scala +++ b/src/library/scala/Function11.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 11 parameters. +/** A function of 11 parameters. * */ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)).curried @@ -28,10 +29,13 @@ trait Function11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] ex @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) == (f.tupled)(Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) + /** Creates a tupled version of this function: instead of 11 arguments, + * it accepts a single [[scala.Tuple11]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) == f(Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)` */ def tupled: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] => R = { case Tuple11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) } - + override def toString() = "" } diff --git a/src/library/scala/Function12.scala b/src/library/scala/Function12.scala index eda1a0510d..bb25c62ceb 100644 --- a/src/library/scala/Function12.scala +++ b/src/library/scala/Function12.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 12 parameters. +/** A function of 12 parameters. * */ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)).curried @@ -28,10 +29,13 @@ trait Function12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) == (f.tupled)(Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) + /** Creates a tupled version of this function: instead of 12 arguments, + * it accepts a single [[scala.Tuple12]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) == f(Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)` */ def tupled: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] => R = { case Tuple12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) } - + override def toString() = "" } diff --git a/src/library/scala/Function13.scala b/src/library/scala/Function13.scala index 855bfc1ded..19cdf0103c 100644 --- a/src/library/scala/Function13.scala +++ b/src/library/scala/Function13.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 13 parameters. +/** A function of 13 parameters. * */ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)).curried @@ -28,10 +29,13 @@ trait Function13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) == (f.tupled)(Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) + /** Creates a tupled version of this function: instead of 13 arguments, + * it accepts a single [[scala.Tuple13]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) == f(Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)` */ def tupled: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] => R = { case Tuple13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) } - + override def toString() = "" } diff --git a/src/library/scala/Function14.scala b/src/library/scala/Function14.scala index 73ded1a572..258dc230c3 100644 --- a/src/library/scala/Function14.scala +++ b/src/library/scala/Function14.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 14 parameters. +/** A function of 14 parameters. * */ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)).curried @@ -28,10 +29,13 @@ trait Function14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) == (f.tupled)(Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) + /** Creates a tupled version of this function: instead of 14 arguments, + * it accepts a single [[scala.Tuple14]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) == f(Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)` */ def tupled: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] => R = { case Tuple14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) } - + override def toString() = "" } diff --git a/src/library/scala/Function15.scala b/src/library/scala/Function15.scala index 7297e304db..6bc63a1c24 100644 --- a/src/library/scala/Function15.scala +++ b/src/library/scala/Function15.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 15 parameters. +/** A function of 15 parameters. * */ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)).curried @@ -28,10 +29,13 @@ trait Function15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) == (f.tupled)(Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) + /** Creates a tupled version of this function: instead of 15 arguments, + * it accepts a single [[scala.Tuple15]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) == f(Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)` */ def tupled: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] => R = { case Tuple15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) } - + override def toString() = "" } diff --git a/src/library/scala/Function16.scala b/src/library/scala/Function16.scala index 2e7bb03d03..f969e0d8ae 100644 --- a/src/library/scala/Function16.scala +++ b/src/library/scala/Function16.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 16 parameters. +/** A function of 16 parameters. * */ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)).curried @@ -28,10 +29,13 @@ trait Function16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) == (f.tupled)(Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) + /** Creates a tupled version of this function: instead of 16 arguments, + * it accepts a single [[scala.Tuple16]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) == f(Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)` */ def tupled: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] => R = { case Tuple16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) } - + override def toString() = "" } diff --git a/src/library/scala/Function17.scala b/src/library/scala/Function17.scala index 185d69c5c4..5218f2fce7 100644 --- a/src/library/scala/Function17.scala +++ b/src/library/scala/Function17.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 17 parameters. +/** A function of 17 parameters. * */ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)).curried @@ -28,10 +29,13 @@ trait Function17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) == (f.tupled)(Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) + /** Creates a tupled version of this function: instead of 17 arguments, + * it accepts a single [[scala.Tuple17]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) == f(Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)` */ def tupled: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] => R = { case Tuple17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) } - + override def toString() = "" } diff --git a/src/library/scala/Function18.scala b/src/library/scala/Function18.scala index 1d7c04ebcb..a68d5e27ae 100644 --- a/src/library/scala/Function18.scala +++ b/src/library/scala/Function18.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 18 parameters. +/** A function of 18 parameters. * */ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17,v18:T18): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)).curried @@ -28,10 +29,13 @@ trait Function18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) == (f.tupled)(Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) + /** Creates a tupled version of this function: instead of 18 arguments, + * it accepts a single [[scala.Tuple18]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) == f(Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)` */ def tupled: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] => R = { case Tuple18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) } - + override def toString() = "" } diff --git a/src/library/scala/Function19.scala b/src/library/scala/Function19.scala index 33b1940a39..8f22c00b76 100644 --- a/src/library/scala/Function19.scala +++ b/src/library/scala/Function19.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 19 parameters. +/** A function of 19 parameters. * */ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17,v18:T18,v19:T19): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)).curried @@ -28,10 +29,13 @@ trait Function19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) == (f.tupled)(Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) + /** Creates a tupled version of this function: instead of 19 arguments, + * it accepts a single [[scala.Tuple19]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) == f(Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)` */ def tupled: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] => R = { case Tuple19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) } - + override def toString() = "" } diff --git a/src/library/scala/Function2.scala b/src/library/scala/Function2.scala index 7bd2504fa5..f8dff7dc75 100644 --- a/src/library/scala/Function2.scala +++ b/src/library/scala/Function2.scala @@ -5,19 +5,15 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with fancy comment) (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 2 parameters. +/** A function of 2 parameters. * - * In the following example the definition of - * max is a shorthand for the anonymous class - * definition anonfun2: + * In the following example, the definition of max is a + * shorthand for the anonymous class definition anonfun2: * * {{{ * object Main extends Application { @@ -26,17 +22,19 @@ package scala * val anonfun2 = new Function2[Int, Int, Int] { * def apply(x: Int, y: Int): Int = if (x < y) y else x * } - * - * println(max(0, 1)) - * println(anonfun2(0, 1)) + * assert(max(0, 1) == anonfun2(0, 1)) * } * }}} */ trait Function2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @specialized(scala.Int, scala.Long, scala.Double) -T2, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double) +R] extends AnyRef { self => - def apply(v1:T1,v2:T2): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2): R - /** f(x1, x2) == (f.curried)(x1)(x2) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2) == apply(x1, x2)` */ def curried: T1 => T2 => R = { (x1: T1) => (x2: T2) => apply(x1, x2) @@ -44,10 +42,13 @@ trait Function2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @speciali @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2) == (f.tupled)(Tuple2(x1, x2)) + /** Creates a tupled version of this function: instead of 2 arguments, + * it accepts a single [[scala.Tuple2]] argument. + * + * @return a function `f` such that `f((x1, x2)) == f(Tuple2(x1, x2)) == apply(x1, x2)` */ def tupled: Tuple2[T1, T2] => R = { case Tuple2(x1, x2) => apply(x1, x2) } - + override def toString() = "" } diff --git a/src/library/scala/Function20.scala b/src/library/scala/Function20.scala index 654ff9a55c..11942c0766 100644 --- a/src/library/scala/Function20.scala +++ b/src/library/scala/Function20.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 20 parameters. +/** A function of 20 parameters. * */ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17,v18:T18,v19:T19,v20:T20): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)).curried @@ -28,10 +29,13 @@ trait Function20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) == (f.tupled)(Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) + /** Creates a tupled version of this function: instead of 20 arguments, + * it accepts a single [[scala.Tuple20]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) == f(Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)` */ def tupled: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] => R = { case Tuple20(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) } - + override def toString() = "" } diff --git a/src/library/scala/Function21.scala b/src/library/scala/Function21.scala index c6b488f795..cb1a38fc06 100644 --- a/src/library/scala/Function21.scala +++ b/src/library/scala/Function21.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 21 parameters. +/** A function of 21 parameters. * */ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17,v18:T18,v19:T19,v20:T20,v21:T21): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)).curried @@ -28,10 +29,13 @@ trait Function21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) == (f.tupled)(Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)) + /** Creates a tupled version of this function: instead of 21 arguments, + * it accepts a single [[scala.Tuple21]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)) == f(Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)` */ def tupled: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] => R = { case Tuple21(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) } - + override def toString() = "" } diff --git a/src/library/scala/Function22.scala b/src/library/scala/Function22.scala index 88fb776c3b..b202a1f437 100644 --- a/src/library/scala/Function22.scala +++ b/src/library/scala/Function22.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 22 parameters. +/** A function of 22 parameters. * */ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9,v10:T10,v11:T11,v12:T12,v13:T13,v14:T14,v15:T15,v16:T16,v17:T17,v18:T18,v19:T19,v20:T20,v21:T21,v22:T22): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9, v10: T10, v11: T11, v12: T12, v13: T13, v14: T14, v15: T15, v16: T16, v17: T17, v18: T18, v19: T19, v20: T20, v21: T21, v22: T22): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21)(x22) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9)(x10)(x11)(x12)(x13)(x14)(x15)(x16)(x17)(x18)(x19)(x20)(x21)(x22) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => T10 => T11 => T12 => T13 => T14 => T15 => T16 => T17 => T18 => T19 => T20 => T21 => T22 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21, x22: T22) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)).curried @@ -28,10 +29,13 @@ trait Function22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) == (f.tupled)(Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) + /** Creates a tupled version of this function: instead of 22 arguments, + * it accepts a single [[scala.Tuple22]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) == f(Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)` */ def tupled: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] => R = { case Tuple22(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) } - + override def toString() = "" } diff --git a/src/library/scala/Function3.scala b/src/library/scala/Function3.scala index f226e2858f..f67ed3cc66 100644 --- a/src/library/scala/Function3.scala +++ b/src/library/scala/Function3.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 3 parameters. +/** A function of 3 parameters. * */ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3): R - /** f(x1, x2, x3) == (f.curried)(x1)(x2)(x3) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3) == apply(x1, x2, x3)` */ def curried: T1 => T2 => T3 => R = { (x1: T1) => (x2: T2) => (x3: T3) => apply(x1, x2, x3) @@ -28,10 +29,13 @@ trait Function3[-T1, -T2, -T3, +R] extends AnyRef { self => @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3) == (f.tupled)(Tuple3(x1, x2, x3)) + /** Creates a tupled version of this function: instead of 3 arguments, + * it accepts a single [[scala.Tuple3]] argument. + * + * @return a function `f` such that `f((x1, x2, x3)) == f(Tuple3(x1, x2, x3)) == apply(x1, x2, x3)` */ def tupled: Tuple3[T1, T2, T3] => R = { case Tuple3(x1, x2, x3) => apply(x1, x2, x3) } - + override def toString() = "" } diff --git a/src/library/scala/Function4.scala b/src/library/scala/Function4.scala index 632f5b0680..1e798bb9c5 100644 --- a/src/library/scala/Function4.scala +++ b/src/library/scala/Function4.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 4 parameters. +/** A function of 4 parameters. * */ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4): R - /** f(x1, x2, x3, x4) == (f.curried)(x1)(x2)(x3)(x4) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4) == apply(x1, x2, x3, x4)` */ def curried: T1 => T2 => T3 => T4 => R = { (x1: T1) => (x2: T2) => (x3: T3) => (x4: T4) => apply(x1, x2, x3, x4) @@ -28,10 +29,13 @@ trait Function4[-T1, -T2, -T3, -T4, +R] extends AnyRef { self => @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4) == (f.tupled)(Tuple4(x1, x2, x3, x4)) + /** Creates a tupled version of this function: instead of 4 arguments, + * it accepts a single [[scala.Tuple4]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4)) == f(Tuple4(x1, x2, x3, x4)) == apply(x1, x2, x3, x4)` */ def tupled: Tuple4[T1, T2, T3, T4] => R = { case Tuple4(x1, x2, x3, x4) => apply(x1, x2, x3, x4) } - + override def toString() = "" } diff --git a/src/library/scala/Function5.scala b/src/library/scala/Function5.scala index cd2fc94409..e347afa706 100644 --- a/src/library/scala/Function5.scala +++ b/src/library/scala/Function5.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 5 parameters. +/** A function of 5 parameters. * */ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5): R - /** f(x1, x2, x3, x4, x5) == (f.curried)(x1)(x2)(x3)(x4)(x5) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5) == apply(x1, x2, x3, x4, x5)` */ def curried: T1 => T2 => T3 => T4 => T5 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5) => self.apply(x1, x2, x3, x4, x5)).curried @@ -28,10 +29,13 @@ trait Function5[-T1, -T2, -T3, -T4, -T5, +R] extends AnyRef { self => @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5) == (f.tupled)(Tuple5(x1, x2, x3, x4, x5)) + /** Creates a tupled version of this function: instead of 5 arguments, + * it accepts a single [[scala.Tuple5]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5)) == f(Tuple5(x1, x2, x3, x4, x5)) == apply(x1, x2, x3, x4, x5)` */ def tupled: Tuple5[T1, T2, T3, T4, T5] => R = { case Tuple5(x1, x2, x3, x4, x5) => apply(x1, x2, x3, x4, x5) } - + override def toString() = "" } diff --git a/src/library/scala/Function6.scala b/src/library/scala/Function6.scala index aef3e2689c..3818bac6ee 100644 --- a/src/library/scala/Function6.scala +++ b/src/library/scala/Function6.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 6 parameters. +/** A function of 6 parameters. * */ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6): R - /** f(x1, x2, x3, x4, x5, x6) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6) == apply(x1, x2, x3, x4, x5, x6)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6) => self.apply(x1, x2, x3, x4, x5, x6)).curried @@ -28,10 +29,13 @@ trait Function6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends AnyRef { self => @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6) == (f.tupled)(Tuple6(x1, x2, x3, x4, x5, x6)) + /** Creates a tupled version of this function: instead of 6 arguments, + * it accepts a single [[scala.Tuple6]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6)) == f(Tuple6(x1, x2, x3, x4, x5, x6)) == apply(x1, x2, x3, x4, x5, x6)` */ def tupled: Tuple6[T1, T2, T3, T4, T5, T6] => R = { case Tuple6(x1, x2, x3, x4, x5, x6) => apply(x1, x2, x3, x4, x5, x6) } - + override def toString() = "" } diff --git a/src/library/scala/Function7.scala b/src/library/scala/Function7.scala index 838e44d55f..6c03f51e81 100644 --- a/src/library/scala/Function7.scala +++ b/src/library/scala/Function7.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 7 parameters. +/** A function of 7 parameters. * */ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7): R - /** f(x1, x2, x3, x4, x5, x6, x7) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7) == apply(x1, x2, x3, x4, x5, x6, x7)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => self.apply(x1, x2, x3, x4, x5, x6, x7)).curried @@ -28,10 +29,13 @@ trait Function7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends AnyRef { self => @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7) == (f.tupled)(Tuple7(x1, x2, x3, x4, x5, x6, x7)) + /** Creates a tupled version of this function: instead of 7 arguments, + * it accepts a single [[scala.Tuple7]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7)) == f(Tuple7(x1, x2, x3, x4, x5, x6, x7)) == apply(x1, x2, x3, x4, x5, x6, x7)` */ def tupled: Tuple7[T1, T2, T3, T4, T5, T6, T7] => R = { case Tuple7(x1, x2, x3, x4, x5, x6, x7) => apply(x1, x2, x3, x4, x5, x6, x7) } - + override def toString() = "" } diff --git a/src/library/scala/Function8.scala b/src/library/scala/Function8.scala index 5bed6b4299..eb5065835d 100644 --- a/src/library/scala/Function8.scala +++ b/src/library/scala/Function8.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 8 parameters. +/** A function of 8 parameters. * */ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8) == apply(x1, x2, x3, x4, x5, x6, x7, x8)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8)).curried @@ -28,10 +29,13 @@ trait Function8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends AnyRef { sel @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8) == (f.tupled)(Tuple8(x1, x2, x3, x4, x5, x6, x7, x8)) + /** Creates a tupled version of this function: instead of 8 arguments, + * it accepts a single [[scala.Tuple8]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8)) == f(Tuple8(x1, x2, x3, x4, x5, x6, x7, x8)) == apply(x1, x2, x3, x4, x5, x6, x7, x8)` */ def tupled: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8] => R = { case Tuple8(x1, x2, x3, x4, x5, x6, x7, x8) => apply(x1, x2, x3, x4, x5, x6, x7, x8) } - + override def toString() = "" } diff --git a/src/library/scala/Function9.scala b/src/library/scala/Function9.scala index 88c1af28b6..a5a132b52a 100644 --- a/src/library/scala/Function9.scala +++ b/src/library/scala/Function9.scala @@ -5,22 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Function with 9 parameters. +/** A function of 9 parameters. * */ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef { self => - def apply(v1:T1,v2:T2,v3:T3,v4:T4,v5:T5,v6:T6,v7:T7,v8:T8,v9:T9): R - override def toString() = "" + /** Apply the body of this function to the arguments. + * @return the result of function application. + */ + def apply(v1: T1, v2: T2, v3: T3, v4: T4, v5: T5, v6: T6, v7: T7, v8: T8, v9: T9): R - /** f(x1, x2, x3, x4, x5, x6, x7, x8, x9) == (f.curried)(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9) + /** Creates a curried version of this function. + * + * @return a function `f` such that `f(x1)(x2)(x3)(x4)(x5)(x6)(x7)(x8)(x9) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)` */ def curried: T1 => T2 => T3 => T4 => T5 => T6 => T7 => T8 => T9 => R = { (x1: T1) => ((x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9) => self.apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)).curried @@ -28,10 +29,13 @@ trait Function9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends AnyRef @deprecated("Use 'curried' instead") def curry = curried - /* f(x1, x2, x3, x4, x5, x6, x7, x8, x9) == (f.tupled)(Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9)) + /** Creates a tupled version of this function: instead of 9 arguments, + * it accepts a single [[scala.Tuple9]] argument. + * + * @return a function `f` such that `f((x1, x2, x3, x4, x5, x6, x7, x8, x9)) == f(Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9)) == apply(x1, x2, x3, x4, x5, x6, x7, x8, x9)` */ def tupled: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9] => R = { case Tuple9(x1, x2, x3, x4, x5, x6, x7, x8, x9) => apply(x1, x2, x3, x4, x5, x6, x7, x8, x9) } - + override def toString() = "" } diff --git a/src/library/scala/PartialFunction.scala b/src/library/scala/PartialFunction.scala index aae01eea94..c4af0f01e4 100644 --- a/src/library/scala/PartialFunction.scala +++ b/src/library/scala/PartialFunction.scala @@ -59,14 +59,12 @@ trait PartialFunction[-A, +B] extends (A => B) { } /** Turns this partial function into an plain function returning an `Option` result. - * @see Function1#unlift + * @see Function.unlift * @return a function that takes an argument `x` to `Some(this(x))` if `this` * is defined for `x`, and to `None` otherwise. */ def lift: A => Option[B] = new (A => Option[B]) { def apply(x: A): Option[B] = if (isDefinedAt(x)) Some(PartialFunction.this.apply(x)) else None - override def unlift[R1](implicit ev: Option[B] <:< Option[R1]): PartialFunction[A, R1] = - PartialFunction.this.asInstanceOf[PartialFunction[A, R1]] } } diff --git a/src/library/scala/Product1.scala b/src/library/scala/Product1.scala index 9345d77874..ab8b0a4505 100644 --- a/src/library/scala/Product1.scala +++ b/src/library/scala/Product1.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product1 { def unapply[T1](x: Product1[T1]): Option[Product1[T1]] = Some(x) } /** Product1 is a cartesian product of 1 component. - * * @since 2.3 */ trait Product1[@specialized(Int, Long, Double) +T1] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 1 */ override def productArity = 1 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -44,9 +38,10 @@ trait Product1[@specialized(Int, Long, Double) +T1] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - } diff --git a/src/library/scala/Product10.scala b/src/library/scala/Product10.scala index b50b68d51a..536fb2fed9 100644 --- a/src/library/scala/Product10.scala +++ b/src/library/scala/Product10.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product10 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](x: Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]): Option[Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = Some(x) } /** Product10 is a cartesian product of 10 components. - * * @since 2.3 */ trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 10 */ override def productArity = 10 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -53,36 +47,46 @@ trait Product10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10] extends Produ case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - } diff --git a/src/library/scala/Product11.scala b/src/library/scala/Product11.scala index a3b104e19f..7d49eccc5e 100644 --- a/src/library/scala/Product11.scala +++ b/src/library/scala/Product11.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product11 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](x: Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]): Option[Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = Some(x) } /** Product11 is a cartesian product of 11 components. - * * @since 2.3 */ trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 11 */ override def productArity = 11 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -54,39 +48,50 @@ trait Product11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11] extends case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - } diff --git a/src/library/scala/Product12.scala b/src/library/scala/Product12.scala index 9107ee9e93..0e9c4a01a2 100644 --- a/src/library/scala/Product12.scala +++ b/src/library/scala/Product12.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product12 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](x: Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]): Option[Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = Some(x) } /** Product12 is a cartesian product of 12 components. - * * @since 2.3 */ trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 12 */ override def productArity = 12 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -55,42 +49,54 @@ trait Product12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12] e case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - } diff --git a/src/library/scala/Product13.scala b/src/library/scala/Product13.scala index 5cc72d6aa4..a0629201d0 100644 --- a/src/library/scala/Product13.scala +++ b/src/library/scala/Product13.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product13 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](x: Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]): Option[Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = Some(x) } /** Product13 is a cartesian product of 13 components. - * * @since 2.3 */ trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 13 */ override def productArity = 13 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -56,45 +50,58 @@ trait Product13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - } diff --git a/src/library/scala/Product14.scala b/src/library/scala/Product14.scala index ada8a414b2..32dda81c3e 100644 --- a/src/library/scala/Product14.scala +++ b/src/library/scala/Product14.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product14 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](x: Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]): Option[Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = Some(x) } /** Product14 is a cartesian product of 14 components. - * * @since 2.3 */ trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 14 */ override def productArity = 14 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -57,48 +51,62 @@ trait Product14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - } diff --git a/src/library/scala/Product15.scala b/src/library/scala/Product15.scala index 934de0ce5c..57851f9870 100644 --- a/src/library/scala/Product15.scala +++ b/src/library/scala/Product15.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product15 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](x: Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]): Option[Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = Some(x) } /** Product15 is a cartesian product of 15 components. - * * @since 2.3 */ trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 15 */ override def productArity = 15 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -58,51 +52,66 @@ trait Product15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - } diff --git a/src/library/scala/Product16.scala b/src/library/scala/Product16.scala index d4ff76661f..75076f3b3c 100644 --- a/src/library/scala/Product16.scala +++ b/src/library/scala/Product16.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product16 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](x: Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]): Option[Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = Some(x) } /** Product16 is a cartesian product of 16 components. - * * @since 2.3 */ trait Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 16 */ override def productArity = 16 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -59,54 +53,70 @@ trait Product16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - } diff --git a/src/library/scala/Product17.scala b/src/library/scala/Product17.scala index b5326ecc21..9ee6072ffe 100644 --- a/src/library/scala/Product17.scala +++ b/src/library/scala/Product17.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product17 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](x: Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]): Option[Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = Some(x) } /** Product17 is a cartesian product of 17 components. - * * @since 2.3 */ trait Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 17 */ override def productArity = 17 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -60,57 +54,74 @@ trait Product17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - } diff --git a/src/library/scala/Product18.scala b/src/library/scala/Product18.scala index 0172772751..25d0839af1 100644 --- a/src/library/scala/Product18.scala +++ b/src/library/scala/Product18.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product18 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](x: Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]): Option[Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = Some(x) } /** Product18 is a cartesian product of 18 components. - * * @since 2.3 */ trait Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 18 */ override def productArity = 18 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -61,60 +55,78 @@ trait Product18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - - /** projection of this product */ + /** A projection of element 18 of this Product. + * @return A projection of element 18. + */ def _18: T18 - } diff --git a/src/library/scala/Product19.scala b/src/library/scala/Product19.scala index 573fdb2729..5464de7264 100644 --- a/src/library/scala/Product19.scala +++ b/src/library/scala/Product19.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product19 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](x: Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]): Option[Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = Some(x) } /** Product19 is a cartesian product of 19 components. - * * @since 2.3 */ trait Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 19 */ override def productArity = 19 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -62,63 +56,82 @@ trait Product19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - - /** projection of this product */ + /** A projection of element 18 of this Product. + * @return A projection of element 18. + */ def _18: T18 - - /** projection of this product */ + /** A projection of element 19 of this Product. + * @return A projection of element 19. + */ def _19: T19 - } diff --git a/src/library/scala/Product2.scala b/src/library/scala/Product2.scala index ef9c390336..8097245926 100644 --- a/src/library/scala/Product2.scala +++ b/src/library/scala/Product2.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product2 { def unapply[T1, T2](x: Product2[T1, T2]): Option[Product2[T1, T2]] = Some(x) } /** Product2 is a cartesian product of 2 components. - * * @since 2.3 */ trait Product2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Double) +T2] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 2 */ override def productArity = 2 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -45,12 +39,14 @@ trait Product2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Doub case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - } diff --git a/src/library/scala/Product20.scala b/src/library/scala/Product20.scala index 4131f65c4a..b094e09aca 100644 --- a/src/library/scala/Product20.scala +++ b/src/library/scala/Product20.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product20 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](x: Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]): Option[Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = Some(x) } /** Product20 is a cartesian product of 20 components. - * * @since 2.3 */ trait Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 20 */ override def productArity = 20 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -63,66 +57,86 @@ trait Product20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - - /** projection of this product */ + /** A projection of element 18 of this Product. + * @return A projection of element 18. + */ def _18: T18 - - /** projection of this product */ + /** A projection of element 19 of this Product. + * @return A projection of element 19. + */ def _19: T19 - - /** projection of this product */ + /** A projection of element 20 of this Product. + * @return A projection of element 20. + */ def _20: T20 - } diff --git a/src/library/scala/Product21.scala b/src/library/scala/Product21.scala index e08a92499d..fa06cfb438 100644 --- a/src/library/scala/Product21.scala +++ b/src/library/scala/Product21.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product21 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](x: Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]): Option[Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = Some(x) } /** Product21 is a cartesian product of 21 components. - * * @since 2.3 */ trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 21 */ override def productArity = 21 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -64,69 +58,90 @@ trait Product21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - - /** projection of this product */ + /** A projection of element 18 of this Product. + * @return A projection of element 18. + */ def _18: T18 - - /** projection of this product */ + /** A projection of element 19 of this Product. + * @return A projection of element 19. + */ def _19: T19 - - /** projection of this product */ + /** A projection of element 20 of this Product. + * @return A projection of element 20. + */ def _20: T20 - - /** projection of this product */ + /** A projection of element 21 of this Product. + * @return A projection of element 21. + */ def _21: T21 - } diff --git a/src/library/scala/Product22.scala b/src/library/scala/Product22.scala index e8f7879d5e..46038bf1a2 100644 --- a/src/library/scala/Product22.scala +++ b/src/library/scala/Product22.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product22 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](x: Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]): Option[Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = Some(x) } /** Product22 is a cartesian product of 22 components. - * * @since 2.3 */ trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 22 */ override def productArity = 22 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -65,72 +59,94 @@ trait Product22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, + case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - - /** projection of this product */ + /** A projection of element 10 of this Product. + * @return A projection of element 10. + */ def _10: T10 - - /** projection of this product */ + /** A projection of element 11 of this Product. + * @return A projection of element 11. + */ def _11: T11 - - /** projection of this product */ + /** A projection of element 12 of this Product. + * @return A projection of element 12. + */ def _12: T12 - - /** projection of this product */ + /** A projection of element 13 of this Product. + * @return A projection of element 13. + */ def _13: T13 - - /** projection of this product */ + /** A projection of element 14 of this Product. + * @return A projection of element 14. + */ def _14: T14 - - /** projection of this product */ + /** A projection of element 15 of this Product. + * @return A projection of element 15. + */ def _15: T15 - - /** projection of this product */ + /** A projection of element 16 of this Product. + * @return A projection of element 16. + */ def _16: T16 - - /** projection of this product */ + /** A projection of element 17 of this Product. + * @return A projection of element 17. + */ def _17: T17 - - /** projection of this product */ + /** A projection of element 18 of this Product. + * @return A projection of element 18. + */ def _18: T18 - - /** projection of this product */ + /** A projection of element 19 of this Product. + * @return A projection of element 19. + */ def _19: T19 - - /** projection of this product */ + /** A projection of element 20 of this Product. + * @return A projection of element 20. + */ def _20: T20 - - /** projection of this product */ + /** A projection of element 21 of this Product. + * @return A projection of element 21. + */ def _21: T21 - - /** projection of this product */ + /** A projection of element 22 of this Product. + * @return A projection of element 22. + */ def _22: T22 - } diff --git a/src/library/scala/Product3.scala b/src/library/scala/Product3.scala index ef47bccb79..3a4cd8fc5e 100644 --- a/src/library/scala/Product3.scala +++ b/src/library/scala/Product3.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product3 { def unapply[T1, T2, T3](x: Product3[T1, T2, T3]): Option[Product3[T1, T2, T3]] = Some(x) } /** Product3 is a cartesian product of 3 components. - * * @since 2.3 */ trait Product3[+T1, +T2, +T3] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 3 */ override def productArity = 3 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -46,15 +40,18 @@ trait Product3[+T1, +T2, +T3] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - } diff --git a/src/library/scala/Product4.scala b/src/library/scala/Product4.scala index 311bb4d1d3..a4d47457fa 100644 --- a/src/library/scala/Product4.scala +++ b/src/library/scala/Product4.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product4 { def unapply[T1, T2, T3, T4](x: Product4[T1, T2, T3, T4]): Option[Product4[T1, T2, T3, T4]] = Some(x) } /** Product4 is a cartesian product of 4 components. - * * @since 2.3 */ trait Product4[+T1, +T2, +T3, +T4] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 4 */ override def productArity = 4 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -47,18 +41,22 @@ trait Product4[+T1, +T2, +T3, +T4] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - } diff --git a/src/library/scala/Product5.scala b/src/library/scala/Product5.scala index f4ce0e7f48..9f25e70af0 100644 --- a/src/library/scala/Product5.scala +++ b/src/library/scala/Product5.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product5 { def unapply[T1, T2, T3, T4, T5](x: Product5[T1, T2, T3, T4, T5]): Option[Product5[T1, T2, T3, T4, T5]] = Some(x) } /** Product5 is a cartesian product of 5 components. - * * @since 2.3 */ trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 5 */ override def productArity = 5 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -48,21 +42,26 @@ trait Product5[+T1, +T2, +T3, +T4, +T5] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - } diff --git a/src/library/scala/Product6.scala b/src/library/scala/Product6.scala index eede91e3d6..87fd318c68 100644 --- a/src/library/scala/Product6.scala +++ b/src/library/scala/Product6.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product6 { def unapply[T1, T2, T3, T4, T5, T6](x: Product6[T1, T2, T3, T4, T5, T6]): Option[Product6[T1, T2, T3, T4, T5, T6]] = Some(x) } /** Product6 is a cartesian product of 6 components. - * * @since 2.3 */ trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 6 */ override def productArity = 6 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -49,24 +43,30 @@ trait Product6[+T1, +T2, +T3, +T4, +T5, +T6] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - } diff --git a/src/library/scala/Product7.scala b/src/library/scala/Product7.scala index b20501ecff..d074503315 100644 --- a/src/library/scala/Product7.scala +++ b/src/library/scala/Product7.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product7 { def unapply[T1, T2, T3, T4, T5, T6, T7](x: Product7[T1, T2, T3, T4, T5, T6, T7]): Option[Product7[T1, T2, T3, T4, T5, T6, T7]] = Some(x) } /** Product7 is a cartesian product of 7 components. - * * @since 2.3 */ trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 7 */ override def productArity = 7 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -50,27 +44,34 @@ trait Product7[+T1, +T2, +T3, +T4, +T5, +T6, +T7] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - } diff --git a/src/library/scala/Product8.scala b/src/library/scala/Product8.scala index 4e2bfaac04..bd6150c235 100644 --- a/src/library/scala/Product8.scala +++ b/src/library/scala/Product8.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product8 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8](x: Product8[T1, T2, T3, T4, T5, T6, T7, T8]): Option[Product8[T1, T2, T3, T4, T5, T6, T7, T8]] = Some(x) } /** Product8 is a cartesian product of 8 components. - * * @since 2.3 */ trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 8 */ override def productArity = 8 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -51,30 +45,38 @@ trait Product8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - } diff --git a/src/library/scala/Product9.scala b/src/library/scala/Product9.scala index 6402bf9867..1f042944cc 100644 --- a/src/library/scala/Product9.scala +++ b/src/library/scala/Product9.scala @@ -5,36 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - object Product9 { def unapply[T1, T2, T3, T4, T5, T6, T7, T8, T9](x: Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9]): Option[Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = Some(x) } /** Product9 is a cartesian product of 9 components. - * * @since 2.3 */ trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product { - /** - * The arity of this product. + /** The arity of this product. * @return 9 */ override def productArity = 9 - /** - * Returns the n-th projection of this product if 0 < n <= productArity, - * otherwise throws IndexOutOfBoundsException. + /** Returns the n-th projection of this product if 0 < n <= productArity, + * otherwise throws an `IndexOutOfBoundsException`. * * @param n number of the projection to be returned - * @return same as _(n+1) + * @return same as `._(n+1)`, for example `productElement(1)` is the same as `._1`. * @throws IndexOutOfBoundsException */ @@ -52,33 +46,42 @@ trait Product9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9] extends Product { case _ => throw new IndexOutOfBoundsException(n.toString()) } - /** projection of this product */ + /** A projection of element 1 of this Product. + * @return A projection of element 1. + */ def _1: T1 - - /** projection of this product */ + /** A projection of element 2 of this Product. + * @return A projection of element 2. + */ def _2: T2 - - /** projection of this product */ + /** A projection of element 3 of this Product. + * @return A projection of element 3. + */ def _3: T3 - - /** projection of this product */ + /** A projection of element 4 of this Product. + * @return A projection of element 4. + */ def _4: T4 - - /** projection of this product */ + /** A projection of element 5 of this Product. + * @return A projection of element 5. + */ def _5: T5 - - /** projection of this product */ + /** A projection of element 6 of this Product. + * @return A projection of element 6. + */ def _6: T6 - - /** projection of this product */ + /** A projection of element 7 of this Product. + * @return A projection of element 7. + */ def _7: T7 - - /** projection of this product */ + /** A projection of element 8 of this Product. + * @return A projection of element 8. + */ def _8: T8 - - /** projection of this product */ + /** A projection of element 9 of this Product. + * @return A projection of element 9. + */ def _9: T9 - } diff --git a/src/library/scala/Tuple1.scala b/src/library/scala/Tuple1.scala index 771faaa015..6d31d35e51 100644 --- a/src/library/scala/Tuple1.scala +++ b/src/library/scala/Tuple1.scala @@ -5,18 +5,17 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple1 is the canonical representation of a @see Product1 +/** A tuple of 1 elements; the canonical representation of a [[scala.Product1]]. * + * @constructor Create a new tuple with 1 elements. + * @param _1 Element 1 of this Tuple1 */ -case class Tuple1[@specialized(Int, Long, Double) +T1](_1:T1) +case class Tuple1[@specialized(Int, Long, Double) +T1](_1: T1) extends Product1[T1] { override def toString() = "(" + _1 + ")" diff --git a/src/library/scala/Tuple10.scala b/src/library/scala/Tuple10.scala index 0feaded24a..10d554d467 100644 --- a/src/library/scala/Tuple10.scala +++ b/src/library/scala/Tuple10.scala @@ -5,18 +5,26 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple10 is the canonical representation of a @see Product10 +/** A tuple of 10 elements; the canonical representation of a [[scala.Product10]]. * + * @constructor Create a new tuple with 10 elements. Note that it is more idiomatic to create a Tuple10 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10)` + * @param _1 Element 1 of this Tuple10 + * @param _2 Element 2 of this Tuple10 + * @param _3 Element 3 of this Tuple10 + * @param _4 Element 4 of this Tuple10 + * @param _5 Element 5 of this Tuple10 + * @param _6 Element 6 of this Tuple10 + * @param _7 Element 7 of this Tuple10 + * @param _8 Element 8 of this Tuple10 + * @param _9 Element 9 of this Tuple10 + * @param _10 Element 10 of this Tuple10 */ -case class Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10) +case class Tuple10[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10) extends Product10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + ")" diff --git a/src/library/scala/Tuple11.scala b/src/library/scala/Tuple11.scala index 8398583295..2065e4f017 100644 --- a/src/library/scala/Tuple11.scala +++ b/src/library/scala/Tuple11.scala @@ -5,18 +5,27 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple11 is the canonical representation of a @see Product11 +/** A tuple of 11 elements; the canonical representation of a [[scala.Product11]]. * + * @constructor Create a new tuple with 11 elements. Note that it is more idiomatic to create a Tuple11 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11)` + * @param _1 Element 1 of this Tuple11 + * @param _2 Element 2 of this Tuple11 + * @param _3 Element 3 of this Tuple11 + * @param _4 Element 4 of this Tuple11 + * @param _5 Element 5 of this Tuple11 + * @param _6 Element 6 of this Tuple11 + * @param _7 Element 7 of this Tuple11 + * @param _8 Element 8 of this Tuple11 + * @param _9 Element 9 of this Tuple11 + * @param _10 Element 10 of this Tuple11 + * @param _11 Element 11 of this Tuple11 */ -case class Tuple11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11) +case class Tuple11[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11) extends Product11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + "," + _11 + ")" diff --git a/src/library/scala/Tuple12.scala b/src/library/scala/Tuple12.scala index d4accf7e39..a463986752 100644 --- a/src/library/scala/Tuple12.scala +++ b/src/library/scala/Tuple12.scala @@ -5,18 +5,28 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple12 is the canonical representation of a @see Product12 +/** A tuple of 12 elements; the canonical representation of a [[scala.Product12]]. * + * @constructor Create a new tuple with 12 elements. Note that it is more idiomatic to create a Tuple12 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12)` + * @param _1 Element 1 of this Tuple12 + * @param _2 Element 2 of this Tuple12 + * @param _3 Element 3 of this Tuple12 + * @param _4 Element 4 of this Tuple12 + * @param _5 Element 5 of this Tuple12 + * @param _6 Element 6 of this Tuple12 + * @param _7 Element 7 of this Tuple12 + * @param _8 Element 8 of this Tuple12 + * @param _9 Element 9 of this Tuple12 + * @param _10 Element 10 of this Tuple12 + * @param _11 Element 11 of this Tuple12 + * @param _12 Element 12 of this Tuple12 */ -case class Tuple12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12) +case class Tuple12[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12) extends Product12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + diff --git a/src/library/scala/Tuple13.scala b/src/library/scala/Tuple13.scala index 0152298057..2bee0d69ad 100644 --- a/src/library/scala/Tuple13.scala +++ b/src/library/scala/Tuple13.scala @@ -5,18 +5,29 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple13 is the canonical representation of a @see Product13 +/** A tuple of 13 elements; the canonical representation of a [[scala.Product13]]. * + * @constructor Create a new tuple with 13 elements. Note that it is more idiomatic to create a Tuple13 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13)` + * @param _1 Element 1 of this Tuple13 + * @param _2 Element 2 of this Tuple13 + * @param _3 Element 3 of this Tuple13 + * @param _4 Element 4 of this Tuple13 + * @param _5 Element 5 of this Tuple13 + * @param _6 Element 6 of this Tuple13 + * @param _7 Element 7 of this Tuple13 + * @param _8 Element 8 of this Tuple13 + * @param _9 Element 9 of this Tuple13 + * @param _10 Element 10 of this Tuple13 + * @param _11 Element 11 of this Tuple13 + * @param _12 Element 12 of this Tuple13 + * @param _13 Element 13 of this Tuple13 */ -case class Tuple13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13) +case class Tuple13[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13) extends Product13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + diff --git a/src/library/scala/Tuple14.scala b/src/library/scala/Tuple14.scala index 5934ee775d..60f7c51e64 100644 --- a/src/library/scala/Tuple14.scala +++ b/src/library/scala/Tuple14.scala @@ -5,18 +5,30 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple14 is the canonical representation of a @see Product14 +/** A tuple of 14 elements; the canonical representation of a [[scala.Product14]]. * + * @constructor Create a new tuple with 14 elements. Note that it is more idiomatic to create a Tuple14 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14)` + * @param _1 Element 1 of this Tuple14 + * @param _2 Element 2 of this Tuple14 + * @param _3 Element 3 of this Tuple14 + * @param _4 Element 4 of this Tuple14 + * @param _5 Element 5 of this Tuple14 + * @param _6 Element 6 of this Tuple14 + * @param _7 Element 7 of this Tuple14 + * @param _8 Element 8 of this Tuple14 + * @param _9 Element 9 of this Tuple14 + * @param _10 Element 10 of this Tuple14 + * @param _11 Element 11 of this Tuple14 + * @param _12 Element 12 of this Tuple14 + * @param _13 Element 13 of this Tuple14 + * @param _14 Element 14 of this Tuple14 */ -case class Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14) +case class Tuple14[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14) extends Product14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + diff --git a/src/library/scala/Tuple15.scala b/src/library/scala/Tuple15.scala index 6efadc203c..fc8e30580b 100644 --- a/src/library/scala/Tuple15.scala +++ b/src/library/scala/Tuple15.scala @@ -5,18 +5,31 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple15 is the canonical representation of a @see Product15 +/** A tuple of 15 elements; the canonical representation of a [[scala.Product15]]. * + * @constructor Create a new tuple with 15 elements. Note that it is more idiomatic to create a Tuple15 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15)` + * @param _1 Element 1 of this Tuple15 + * @param _2 Element 2 of this Tuple15 + * @param _3 Element 3 of this Tuple15 + * @param _4 Element 4 of this Tuple15 + * @param _5 Element 5 of this Tuple15 + * @param _6 Element 6 of this Tuple15 + * @param _7 Element 7 of this Tuple15 + * @param _8 Element 8 of this Tuple15 + * @param _9 Element 9 of this Tuple15 + * @param _10 Element 10 of this Tuple15 + * @param _11 Element 11 of this Tuple15 + * @param _12 Element 12 of this Tuple15 + * @param _13 Element 13 of this Tuple15 + * @param _14 Element 14 of this Tuple15 + * @param _15 Element 15 of this Tuple15 */ -case class Tuple15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15) +case class Tuple15[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15) extends Product15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + diff --git a/src/library/scala/Tuple16.scala b/src/library/scala/Tuple16.scala index cb3515a5ab..80181f6648 100644 --- a/src/library/scala/Tuple16.scala +++ b/src/library/scala/Tuple16.scala @@ -5,18 +5,32 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple16 is the canonical representation of a @see Product16 +/** A tuple of 16 elements; the canonical representation of a [[scala.Product16]]. * + * @constructor Create a new tuple with 16 elements. Note that it is more idiomatic to create a Tuple16 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16)` + * @param _1 Element 1 of this Tuple16 + * @param _2 Element 2 of this Tuple16 + * @param _3 Element 3 of this Tuple16 + * @param _4 Element 4 of this Tuple16 + * @param _5 Element 5 of this Tuple16 + * @param _6 Element 6 of this Tuple16 + * @param _7 Element 7 of this Tuple16 + * @param _8 Element 8 of this Tuple16 + * @param _9 Element 9 of this Tuple16 + * @param _10 Element 10 of this Tuple16 + * @param _11 Element 11 of this Tuple16 + * @param _12 Element 12 of this Tuple16 + * @param _13 Element 13 of this Tuple16 + * @param _14 Element 14 of this Tuple16 + * @param _15 Element 15 of this Tuple16 + * @param _16 Element 16 of this Tuple16 */ -case class Tuple16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16) +case class Tuple16[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16) extends Product16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + diff --git a/src/library/scala/Tuple17.scala b/src/library/scala/Tuple17.scala index 11294ed0b9..6236122be2 100644 --- a/src/library/scala/Tuple17.scala +++ b/src/library/scala/Tuple17.scala @@ -5,18 +5,33 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple17 is the canonical representation of a @see Product17 +/** A tuple of 17 elements; the canonical representation of a [[scala.Product17]]. * + * @constructor Create a new tuple with 17 elements. Note that it is more idiomatic to create a Tuple17 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17)` + * @param _1 Element 1 of this Tuple17 + * @param _2 Element 2 of this Tuple17 + * @param _3 Element 3 of this Tuple17 + * @param _4 Element 4 of this Tuple17 + * @param _5 Element 5 of this Tuple17 + * @param _6 Element 6 of this Tuple17 + * @param _7 Element 7 of this Tuple17 + * @param _8 Element 8 of this Tuple17 + * @param _9 Element 9 of this Tuple17 + * @param _10 Element 10 of this Tuple17 + * @param _11 Element 11 of this Tuple17 + * @param _12 Element 12 of this Tuple17 + * @param _13 Element 13 of this Tuple17 + * @param _14 Element 14 of this Tuple17 + * @param _15 Element 15 of this Tuple17 + * @param _16 Element 16 of this Tuple17 + * @param _17 Element 17 of this Tuple17 */ -case class Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17) +case class Tuple17[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17) extends Product17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + diff --git a/src/library/scala/Tuple18.scala b/src/library/scala/Tuple18.scala index aaff95733c..dd6a819ac5 100644 --- a/src/library/scala/Tuple18.scala +++ b/src/library/scala/Tuple18.scala @@ -5,18 +5,34 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple18 is the canonical representation of a @see Product18 +/** A tuple of 18 elements; the canonical representation of a [[scala.Product18]]. * + * @constructor Create a new tuple with 18 elements. Note that it is more idiomatic to create a Tuple18 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18)` + * @param _1 Element 1 of this Tuple18 + * @param _2 Element 2 of this Tuple18 + * @param _3 Element 3 of this Tuple18 + * @param _4 Element 4 of this Tuple18 + * @param _5 Element 5 of this Tuple18 + * @param _6 Element 6 of this Tuple18 + * @param _7 Element 7 of this Tuple18 + * @param _8 Element 8 of this Tuple18 + * @param _9 Element 9 of this Tuple18 + * @param _10 Element 10 of this Tuple18 + * @param _11 Element 11 of this Tuple18 + * @param _12 Element 12 of this Tuple18 + * @param _13 Element 13 of this Tuple18 + * @param _14 Element 14 of this Tuple18 + * @param _15 Element 15 of this Tuple18 + * @param _16 Element 16 of this Tuple18 + * @param _17 Element 17 of this Tuple18 + * @param _18 Element 18 of this Tuple18 */ -case class Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17,_18:T18) +case class Tuple18[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18) extends Product18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + diff --git a/src/library/scala/Tuple19.scala b/src/library/scala/Tuple19.scala index 22c7eb5657..65f0fd22cf 100644 --- a/src/library/scala/Tuple19.scala +++ b/src/library/scala/Tuple19.scala @@ -5,18 +5,35 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple19 is the canonical representation of a @see Product19 +/** A tuple of 19 elements; the canonical representation of a [[scala.Product19]]. * + * @constructor Create a new tuple with 19 elements. Note that it is more idiomatic to create a Tuple19 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19)` + * @param _1 Element 1 of this Tuple19 + * @param _2 Element 2 of this Tuple19 + * @param _3 Element 3 of this Tuple19 + * @param _4 Element 4 of this Tuple19 + * @param _5 Element 5 of this Tuple19 + * @param _6 Element 6 of this Tuple19 + * @param _7 Element 7 of this Tuple19 + * @param _8 Element 8 of this Tuple19 + * @param _9 Element 9 of this Tuple19 + * @param _10 Element 10 of this Tuple19 + * @param _11 Element 11 of this Tuple19 + * @param _12 Element 12 of this Tuple19 + * @param _13 Element 13 of this Tuple19 + * @param _14 Element 14 of this Tuple19 + * @param _15 Element 15 of this Tuple19 + * @param _16 Element 16 of this Tuple19 + * @param _17 Element 17 of this Tuple19 + * @param _18 Element 18 of this Tuple19 + * @param _19 Element 19 of this Tuple19 */ -case class Tuple19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17,_18:T18,_19:T19) +case class Tuple19[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19) extends Product19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + diff --git a/src/library/scala/Tuple2.scala b/src/library/scala/Tuple2.scala index 9652f2e602..fc9b348fdb 100644 --- a/src/library/scala/Tuple2.scala +++ b/src/library/scala/Tuple2.scala @@ -5,8 +5,7 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Wed Oct 27 14:26:15 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala @@ -14,17 +13,21 @@ import scala.collection.{ TraversableLike => TLike, IterableLike => ILike } import scala.collection.generic.{ CanBuildFrom => CBF } - - -/** Tuple2 is the canonical representation of a @see Product2 +/** A tuple of 2 elements; the canonical representation of a [[scala.Product2]]. * + * @constructor Create a new tuple with 2 elements. Note that it is more idiomatic to create a Tuple2 via `(t1, t2)` + * @param _1 Element 1 of this Tuple2 + * @param _2 Element 2 of this Tuple2 */ -case class Tuple2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Double) +T2](_1:T1,_2:T2) +case class Tuple2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, Double) +T2](_1: T1, _2: T2) extends Product2[T1, T2] { override def toString() = "(" + _1 + "," + _2 + ")" - /** Swap the elements of the tuple */ + /** Swaps the elements of this `Tuple`. + * @return a new Tuple where the first element is the second element of this Tuple and the + * second element is the first element of this Tuple. + */ def swap: Tuple2[T2,T1] = Tuple2(_2, _1) @deprecated("Use `zipped` instead.") @@ -34,7 +37,16 @@ case class Tuple2[@specialized(Int, Long, Double) +T1, @specialized(Int, Long, D zipped map ((x, y) => ((x, y))) } - /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of map, flatMap, filter,... + /** Wraps a tuple in a `Zipped`, which supports 2-ary generalisations of `map`, `flatMap`, `filter`, etc. + * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] + * or [[scala.collection.IterableLike]]. + * {{{ + * scala> val tuple = (List(1,2,3),List('a','b','c')) + * tuple: (List[Int], List[Char]) = (List(1, 2, 3),List(a, b, c)) + * + * scala> tuple.zipped map { (x,y) => x + ":" + y } + * res6: List[java.lang.String] = List(1:a, 2:b, 3:c) + * }}} * * @see Zipped * $willNotTerminateInf diff --git a/src/library/scala/Tuple20.scala b/src/library/scala/Tuple20.scala index 1d68642176..cf3626909d 100644 --- a/src/library/scala/Tuple20.scala +++ b/src/library/scala/Tuple20.scala @@ -5,18 +5,36 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple20 is the canonical representation of a @see Product20 +/** A tuple of 20 elements; the canonical representation of a [[scala.Product20]]. * + * @constructor Create a new tuple with 20 elements. Note that it is more idiomatic to create a Tuple20 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20)` + * @param _1 Element 1 of this Tuple20 + * @param _2 Element 2 of this Tuple20 + * @param _3 Element 3 of this Tuple20 + * @param _4 Element 4 of this Tuple20 + * @param _5 Element 5 of this Tuple20 + * @param _6 Element 6 of this Tuple20 + * @param _7 Element 7 of this Tuple20 + * @param _8 Element 8 of this Tuple20 + * @param _9 Element 9 of this Tuple20 + * @param _10 Element 10 of this Tuple20 + * @param _11 Element 11 of this Tuple20 + * @param _12 Element 12 of this Tuple20 + * @param _13 Element 13 of this Tuple20 + * @param _14 Element 14 of this Tuple20 + * @param _15 Element 15 of this Tuple20 + * @param _16 Element 16 of this Tuple20 + * @param _17 Element 17 of this Tuple20 + * @param _18 Element 18 of this Tuple20 + * @param _19 Element 19 of this Tuple20 + * @param _20 Element 20 of this Tuple20 */ -case class Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17,_18:T18,_19:T19,_20:T20) +case class Tuple20[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20) extends Product20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + diff --git a/src/library/scala/Tuple21.scala b/src/library/scala/Tuple21.scala index 8ccb44b099..78b9c585c6 100644 --- a/src/library/scala/Tuple21.scala +++ b/src/library/scala/Tuple21.scala @@ -5,18 +5,37 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple21 is the canonical representation of a @see Product21 +/** A tuple of 21 elements; the canonical representation of a [[scala.Product21]]. * + * @constructor Create a new tuple with 21 elements. Note that it is more idiomatic to create a Tuple21 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21)` + * @param _1 Element 1 of this Tuple21 + * @param _2 Element 2 of this Tuple21 + * @param _3 Element 3 of this Tuple21 + * @param _4 Element 4 of this Tuple21 + * @param _5 Element 5 of this Tuple21 + * @param _6 Element 6 of this Tuple21 + * @param _7 Element 7 of this Tuple21 + * @param _8 Element 8 of this Tuple21 + * @param _9 Element 9 of this Tuple21 + * @param _10 Element 10 of this Tuple21 + * @param _11 Element 11 of this Tuple21 + * @param _12 Element 12 of this Tuple21 + * @param _13 Element 13 of this Tuple21 + * @param _14 Element 14 of this Tuple21 + * @param _15 Element 15 of this Tuple21 + * @param _16 Element 16 of this Tuple21 + * @param _17 Element 17 of this Tuple21 + * @param _18 Element 18 of this Tuple21 + * @param _19 Element 19 of this Tuple21 + * @param _20 Element 20 of this Tuple21 + * @param _21 Element 21 of this Tuple21 */ -case class Tuple21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17,_18:T18,_19:T19,_20:T20,_21:T21) +case class Tuple21[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21) extends Product21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + diff --git a/src/library/scala/Tuple22.scala b/src/library/scala/Tuple22.scala index a20ec95b55..0993dfbbc3 100644 --- a/src/library/scala/Tuple22.scala +++ b/src/library/scala/Tuple22.scala @@ -5,18 +5,38 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple22 is the canonical representation of a @see Product22 +/** A tuple of 22 elements; the canonical representation of a [[scala.Product22]]. * + * @constructor Create a new tuple with 22 elements. Note that it is more idiomatic to create a Tuple22 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22)` + * @param _1 Element 1 of this Tuple22 + * @param _2 Element 2 of this Tuple22 + * @param _3 Element 3 of this Tuple22 + * @param _4 Element 4 of this Tuple22 + * @param _5 Element 5 of this Tuple22 + * @param _6 Element 6 of this Tuple22 + * @param _7 Element 7 of this Tuple22 + * @param _8 Element 8 of this Tuple22 + * @param _9 Element 9 of this Tuple22 + * @param _10 Element 10 of this Tuple22 + * @param _11 Element 11 of this Tuple22 + * @param _12 Element 12 of this Tuple22 + * @param _13 Element 13 of this Tuple22 + * @param _14 Element 14 of this Tuple22 + * @param _15 Element 15 of this Tuple22 + * @param _16 Element 16 of this Tuple22 + * @param _17 Element 17 of this Tuple22 + * @param _18 Element 18 of this Tuple22 + * @param _19 Element 19 of this Tuple22 + * @param _20 Element 20 of this Tuple22 + * @param _21 Element 21 of this Tuple22 + * @param _22 Element 22 of this Tuple22 */ -case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9,_10:T10,_11:T11,_12:T12,_13:T13,_14:T14,_15:T15,_16:T16,_17:T17,_18:T18,_19:T19,_20:T20,_21:T21,_22:T22) +case class Tuple22[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9, +T10, +T11, +T12, +T13, +T14, +T15, +T16, +T17, +T18, +T19, +T20, +T21, +T22](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9, _10: T10, _11: T11, _12: T12, _13: T13, _14: T14, _15: T15, _16: T16, _17: T17, _18: T18, _19: T19, _20: T20, _21: T21, _22: T22) extends Product22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + "," + _10 + "," + _11 + diff --git a/src/library/scala/Tuple3.scala b/src/library/scala/Tuple3.scala index 5ccf76c40b..2f533b10b2 100644 --- a/src/library/scala/Tuple3.scala +++ b/src/library/scala/Tuple3.scala @@ -5,8 +5,7 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Wed Oct 27 14:26:15 PDT 2010 (with extra methods) +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala @@ -14,12 +13,14 @@ import scala.collection.{ TraversableLike => TLike, IterableLike => ILike } import scala.collection.generic.{ CanBuildFrom => CBF } - - -/** Tuple3 is the canonical representation of a @see Product3 +/** A tuple of 3 elements; the canonical representation of a [[scala.Product3]]. * + * @constructor Create a new tuple with 3 elements. Note that it is more idiomatic to create a Tuple3 via `(t1, t2, t3)` + * @param _1 Element 1 of this Tuple3 + * @param _2 Element 2 of this Tuple3 + * @param _3 Element 3 of this Tuple3 */ -case class Tuple3[+T1, +T2, +T3](_1:T1,_2:T2,_3:T3) +case class Tuple3[+T1, +T2, +T3](_1: T1, _2: T2, _3: T3) extends Product3[T1, T2, T3] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + ")" @@ -33,7 +34,16 @@ case class Tuple3[+T1, +T2, +T3](_1:T1,_2:T2,_3:T3) zipped map ((x, y, z) => ((x, y, z))) } - /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of map, flatMap, filter,... + /** Wraps a tuple in a `Zipped`, which supports 3-ary generalisations of `map`, `flatMap`, `filter`, etc. + * Note that there must be an implicit value to convert this tuple's types into a [[scala.collection.TraversableLike]] + * or [[scala.collection.IterableLike]]. + * {{{ + * scala> val tuple = (List(1,2,3),List('a','b','c'),List("x","y","z")) + * tuple: (List[Int], List[Char], List[java.lang.String]) = (List(1, 2, 3),List(a, b, c),List(x, y, z)) + * + * scala> tuple.zipped map { (x,y,z) => x + ":" + y + ":" + z} + * res8: List[java.lang.String] = List(1:a:x, 2:b:y, 3:c:z) + * }}} * * @see Zipped * $willNotTerminateInf diff --git a/src/library/scala/Tuple4.scala b/src/library/scala/Tuple4.scala index a183958a08..a919072c88 100644 --- a/src/library/scala/Tuple4.scala +++ b/src/library/scala/Tuple4.scala @@ -5,18 +5,20 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple4 is the canonical representation of a @see Product4 +/** A tuple of 4 elements; the canonical representation of a [[scala.Product4]]. * + * @constructor Create a new tuple with 4 elements. Note that it is more idiomatic to create a Tuple4 via `(t1, t2, t3, t4)` + * @param _1 Element 1 of this Tuple4 + * @param _2 Element 2 of this Tuple4 + * @param _3 Element 3 of this Tuple4 + * @param _4 Element 4 of this Tuple4 */ -case class Tuple4[+T1, +T2, +T3, +T4](_1:T1,_2:T2,_3:T3,_4:T4) +case class Tuple4[+T1, +T2, +T3, +T4](_1: T1, _2: T2, _3: T3, _4: T4) extends Product4[T1, T2, T3, T4] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + ")" diff --git a/src/library/scala/Tuple5.scala b/src/library/scala/Tuple5.scala index f59015ef9e..6a94f48ab4 100644 --- a/src/library/scala/Tuple5.scala +++ b/src/library/scala/Tuple5.scala @@ -5,18 +5,21 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple5 is the canonical representation of a @see Product5 +/** A tuple of 5 elements; the canonical representation of a [[scala.Product5]]. * + * @constructor Create a new tuple with 5 elements. Note that it is more idiomatic to create a Tuple5 via `(t1, t2, t3, t4, t5)` + * @param _1 Element 1 of this Tuple5 + * @param _2 Element 2 of this Tuple5 + * @param _3 Element 3 of this Tuple5 + * @param _4 Element 4 of this Tuple5 + * @param _5 Element 5 of this Tuple5 */ -case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5) +case class Tuple5[+T1, +T2, +T3, +T4, +T5](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5) extends Product5[T1, T2, T3, T4, T5] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + ")" diff --git a/src/library/scala/Tuple6.scala b/src/library/scala/Tuple6.scala index 15de6bdf25..34f8224627 100644 --- a/src/library/scala/Tuple6.scala +++ b/src/library/scala/Tuple6.scala @@ -5,18 +5,22 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple6 is the canonical representation of a @see Product6 +/** A tuple of 6 elements; the canonical representation of a [[scala.Product6]]. * + * @constructor Create a new tuple with 6 elements. Note that it is more idiomatic to create a Tuple6 via `(t1, t2, t3, t4, t5, t6)` + * @param _1 Element 1 of this Tuple6 + * @param _2 Element 2 of this Tuple6 + * @param _3 Element 3 of this Tuple6 + * @param _4 Element 4 of this Tuple6 + * @param _5 Element 5 of this Tuple6 + * @param _6 Element 6 of this Tuple6 */ -case class Tuple6[+T1, +T2, +T3, +T4, +T5, +T6](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6) +case class Tuple6[+T1, +T2, +T3, +T4, +T5, +T6](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6) extends Product6[T1, T2, T3, T4, T5, T6] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + ")" diff --git a/src/library/scala/Tuple7.scala b/src/library/scala/Tuple7.scala index 67556272d4..6fc3477ba2 100644 --- a/src/library/scala/Tuple7.scala +++ b/src/library/scala/Tuple7.scala @@ -5,18 +5,23 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple7 is the canonical representation of a @see Product7 +/** A tuple of 7 elements; the canonical representation of a [[scala.Product7]]. * + * @constructor Create a new tuple with 7 elements. Note that it is more idiomatic to create a Tuple7 via `(t1, t2, t3, t4, t5, t6, t7)` + * @param _1 Element 1 of this Tuple7 + * @param _2 Element 2 of this Tuple7 + * @param _3 Element 3 of this Tuple7 + * @param _4 Element 4 of this Tuple7 + * @param _5 Element 5 of this Tuple7 + * @param _6 Element 6 of this Tuple7 + * @param _7 Element 7 of this Tuple7 */ -case class Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7) +case class Tuple7[+T1, +T2, +T3, +T4, +T5, +T6, +T7](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7) extends Product7[T1, T2, T3, T4, T5, T6, T7] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + ")" diff --git a/src/library/scala/Tuple8.scala b/src/library/scala/Tuple8.scala index 3052d74385..1e21b684fc 100644 --- a/src/library/scala/Tuple8.scala +++ b/src/library/scala/Tuple8.scala @@ -5,18 +5,24 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple8 is the canonical representation of a @see Product8 +/** A tuple of 8 elements; the canonical representation of a [[scala.Product8]]. * + * @constructor Create a new tuple with 8 elements. Note that it is more idiomatic to create a Tuple8 via `(t1, t2, t3, t4, t5, t6, t7, t8)` + * @param _1 Element 1 of this Tuple8 + * @param _2 Element 2 of this Tuple8 + * @param _3 Element 3 of this Tuple8 + * @param _4 Element 4 of this Tuple8 + * @param _5 Element 5 of this Tuple8 + * @param _6 Element 6 of this Tuple8 + * @param _7 Element 7 of this Tuple8 + * @param _8 Element 8 of this Tuple8 */ -case class Tuple8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8) +case class Tuple8[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8) extends Product8[T1, T2, T3, T4, T5, T6, T7, T8] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + ")" diff --git a/src/library/scala/Tuple9.scala b/src/library/scala/Tuple9.scala index f033c8d14e..453cea31a1 100644 --- a/src/library/scala/Tuple9.scala +++ b/src/library/scala/Tuple9.scala @@ -5,18 +5,25 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala - - -/** Tuple9 is the canonical representation of a @see Product9 +/** A tuple of 9 elements; the canonical representation of a [[scala.Product9]]. * + * @constructor Create a new tuple with 9 elements. Note that it is more idiomatic to create a Tuple9 via `(t1, t2, t3, t4, t5, t6, t7, t8, t9)` + * @param _1 Element 1 of this Tuple9 + * @param _2 Element 2 of this Tuple9 + * @param _3 Element 3 of this Tuple9 + * @param _4 Element 4 of this Tuple9 + * @param _5 Element 5 of this Tuple9 + * @param _6 Element 6 of this Tuple9 + * @param _7 Element 7 of this Tuple9 + * @param _8 Element 8 of this Tuple9 + * @param _9 Element 9 of this Tuple9 */ -case class Tuple9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9](_1:T1,_2:T2,_3:T3,_4:T4,_5:T5,_6:T6,_7:T7,_8:T8,_9:T9) +case class Tuple9[+T1, +T2, +T3, +T4, +T5, +T6, +T7, +T8, +T9](_1: T1, _2: T2, _3: T3, _4: T4, _5: T5, _6: T6, _7: T7, _8: T8, _9: T9) extends Product9[T1, T2, T3, T4, T5, T6, T7, T8, T9] { override def toString() = "(" + _1 + "," + _2 + "," + _3 + "," + _4 + "," + _5 + "," + _6 + "," + _7 + "," + _8 + "," + _9 + ")" diff --git a/src/library/scala/runtime/AbstractFunction0.scala b/src/library/scala/runtime/AbstractFunction0.scala index 3f7375de97..c4ce0ebcdc 100644 --- a/src/library/scala/runtime/AbstractFunction0.scala +++ b/src/library/scala/runtime/AbstractFunction0.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction0[@specialized +R] extends Function0[R] { } diff --git a/src/library/scala/runtime/AbstractFunction1.scala b/src/library/scala/runtime/AbstractFunction1.scala index 40aaf53194..a9e5e90e20 100644 --- a/src/library/scala/runtime/AbstractFunction1.scala +++ b/src/library/scala/runtime/AbstractFunction1.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction1[@specialized(scala.Int, scala.Long, scala.Float, scala.Double) -T1, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double) +R] extends Function1[T1, R] { } diff --git a/src/library/scala/runtime/AbstractFunction10.scala b/src/library/scala/runtime/AbstractFunction10.scala index a7b764386a..72c0a2e69d 100644 --- a/src/library/scala/runtime/AbstractFunction10.scala +++ b/src/library/scala/runtime/AbstractFunction10.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction10[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, +R] extends Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R] { } diff --git a/src/library/scala/runtime/AbstractFunction11.scala b/src/library/scala/runtime/AbstractFunction11.scala index 6061e3db93..031f3044a1 100644 --- a/src/library/scala/runtime/AbstractFunction11.scala +++ b/src/library/scala/runtime/AbstractFunction11.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction11[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, +R] extends Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] { } diff --git a/src/library/scala/runtime/AbstractFunction12.scala b/src/library/scala/runtime/AbstractFunction12.scala index d7ae22396b..9823edbc60 100644 --- a/src/library/scala/runtime/AbstractFunction12.scala +++ b/src/library/scala/runtime/AbstractFunction12.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction12[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, +R] extends Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] { } diff --git a/src/library/scala/runtime/AbstractFunction13.scala b/src/library/scala/runtime/AbstractFunction13.scala index 7ba92e5dfa..528719b216 100644 --- a/src/library/scala/runtime/AbstractFunction13.scala +++ b/src/library/scala/runtime/AbstractFunction13.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction13[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, +R] extends Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] { } diff --git a/src/library/scala/runtime/AbstractFunction14.scala b/src/library/scala/runtime/AbstractFunction14.scala index cc6ee55a10..ecae45a107 100644 --- a/src/library/scala/runtime/AbstractFunction14.scala +++ b/src/library/scala/runtime/AbstractFunction14.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction14[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, +R] extends Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, R] { } diff --git a/src/library/scala/runtime/AbstractFunction15.scala b/src/library/scala/runtime/AbstractFunction15.scala index c33bbe91e8..5f5e8afcf7 100644 --- a/src/library/scala/runtime/AbstractFunction15.scala +++ b/src/library/scala/runtime/AbstractFunction15.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction15[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, +R] extends Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, R] { } diff --git a/src/library/scala/runtime/AbstractFunction16.scala b/src/library/scala/runtime/AbstractFunction16.scala index a3dd295436..c0093c4fbb 100644 --- a/src/library/scala/runtime/AbstractFunction16.scala +++ b/src/library/scala/runtime/AbstractFunction16.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction16[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, +R] extends Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, R] { } diff --git a/src/library/scala/runtime/AbstractFunction17.scala b/src/library/scala/runtime/AbstractFunction17.scala index b107ce03db..caae343a79 100644 --- a/src/library/scala/runtime/AbstractFunction17.scala +++ b/src/library/scala/runtime/AbstractFunction17.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction17[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, +R] extends Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] { } diff --git a/src/library/scala/runtime/AbstractFunction18.scala b/src/library/scala/runtime/AbstractFunction18.scala index 35d8f623a4..9a2bdffee1 100644 --- a/src/library/scala/runtime/AbstractFunction18.scala +++ b/src/library/scala/runtime/AbstractFunction18.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction18[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, +R] extends Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] { } diff --git a/src/library/scala/runtime/AbstractFunction19.scala b/src/library/scala/runtime/AbstractFunction19.scala index 55b0333e35..1dbbd61004 100644 --- a/src/library/scala/runtime/AbstractFunction19.scala +++ b/src/library/scala/runtime/AbstractFunction19.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction19[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, +R] extends Function19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R] { } diff --git a/src/library/scala/runtime/AbstractFunction2.scala b/src/library/scala/runtime/AbstractFunction2.scala index 3d3cc26845..0905ea178c 100644 --- a/src/library/scala/runtime/AbstractFunction2.scala +++ b/src/library/scala/runtime/AbstractFunction2.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction2[@specialized(scala.Int, scala.Long, scala.Double) -T1, @specialized(scala.Int, scala.Long, scala.Double) -T2, @specialized(scala.Unit, scala.Boolean, scala.Int, scala.Float, scala.Long, scala.Double) +R] extends Function2[T1, T2, R] { } diff --git a/src/library/scala/runtime/AbstractFunction20.scala b/src/library/scala/runtime/AbstractFunction20.scala index d08db44d75..eb4c085427 100644 --- a/src/library/scala/runtime/AbstractFunction20.scala +++ b/src/library/scala/runtime/AbstractFunction20.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction20[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, +R] extends Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R] { } diff --git a/src/library/scala/runtime/AbstractFunction21.scala b/src/library/scala/runtime/AbstractFunction21.scala index c5a6ad3de7..98e32b22f1 100644 --- a/src/library/scala/runtime/AbstractFunction21.scala +++ b/src/library/scala/runtime/AbstractFunction21.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction21[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, +R] extends Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R] { } diff --git a/src/library/scala/runtime/AbstractFunction22.scala b/src/library/scala/runtime/AbstractFunction22.scala index 211dd49a04..67b13399d1 100644 --- a/src/library/scala/runtime/AbstractFunction22.scala +++ b/src/library/scala/runtime/AbstractFunction22.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction22[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, -T10, -T11, -T12, -T13, -T14, -T15, -T16, -T17, -T18, -T19, -T20, -T21, -T22, +R] extends Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] { } diff --git a/src/library/scala/runtime/AbstractFunction3.scala b/src/library/scala/runtime/AbstractFunction3.scala index beb299de99..3a45cdcea5 100644 --- a/src/library/scala/runtime/AbstractFunction3.scala +++ b/src/library/scala/runtime/AbstractFunction3.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction3[-T1, -T2, -T3, +R] extends Function3[T1, T2, T3, R] { } diff --git a/src/library/scala/runtime/AbstractFunction4.scala b/src/library/scala/runtime/AbstractFunction4.scala index 9b488c0c7e..fbf55344f6 100644 --- a/src/library/scala/runtime/AbstractFunction4.scala +++ b/src/library/scala/runtime/AbstractFunction4.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction4[-T1, -T2, -T3, -T4, +R] extends Function4[T1, T2, T3, T4, R] { } diff --git a/src/library/scala/runtime/AbstractFunction5.scala b/src/library/scala/runtime/AbstractFunction5.scala index ca99135681..949bae8ab7 100644 --- a/src/library/scala/runtime/AbstractFunction5.scala +++ b/src/library/scala/runtime/AbstractFunction5.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction5[-T1, -T2, -T3, -T4, -T5, +R] extends Function5[T1, T2, T3, T4, T5, R] { } diff --git a/src/library/scala/runtime/AbstractFunction6.scala b/src/library/scala/runtime/AbstractFunction6.scala index 8e3c053784..337fd9f3fc 100644 --- a/src/library/scala/runtime/AbstractFunction6.scala +++ b/src/library/scala/runtime/AbstractFunction6.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction6[-T1, -T2, -T3, -T4, -T5, -T6, +R] extends Function6[T1, T2, T3, T4, T5, T6, R] { } diff --git a/src/library/scala/runtime/AbstractFunction7.scala b/src/library/scala/runtime/AbstractFunction7.scala index 72aee1bab0..24458678ad 100644 --- a/src/library/scala/runtime/AbstractFunction7.scala +++ b/src/library/scala/runtime/AbstractFunction7.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction7[-T1, -T2, -T3, -T4, -T5, -T6, -T7, +R] extends Function7[T1, T2, T3, T4, T5, T6, T7, R] { } diff --git a/src/library/scala/runtime/AbstractFunction8.scala b/src/library/scala/runtime/AbstractFunction8.scala index c8f50bbc84..6d3dac849e 100644 --- a/src/library/scala/runtime/AbstractFunction8.scala +++ b/src/library/scala/runtime/AbstractFunction8.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction8[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, +R] extends Function8[T1, T2, T3, T4, T5, T6, T7, T8, R] { } diff --git a/src/library/scala/runtime/AbstractFunction9.scala b/src/library/scala/runtime/AbstractFunction9.scala index 37455c9946..43cf3d2a74 100644 --- a/src/library/scala/runtime/AbstractFunction9.scala +++ b/src/library/scala/runtime/AbstractFunction9.scala @@ -5,13 +5,10 @@ ** /____/\___/_/ |_/____/_/ | | ** ** |/ ** \* */ - -// generated by genprod on Sat Oct 16 11:19:09 PDT 2010 +// GENERATED CODE: DO NOT EDIT. See scala.Function0 for timestamp. package scala.runtime - - abstract class AbstractFunction9[-T1, -T2, -T3, -T4, -T5, -T6, -T7, -T8, -T9, +R] extends Function9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R] { } -- cgit v1.2.3