"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "library/src/main/scala-old-collections/scala/scalajs/js/Any.scala" between
scala-js-0.6.31.tar.gz and scala-js-1.0.0-RC1.tar.gz

About: Scala.js is a Scala to JavaScript compiler. Release candidate.

Any.scala  (scala-js-0.6.31):Any.scala  (scala-js-1.0.0-RC1)
skipping to change at line 22 skipping to change at line 22
/** /**
* All doc-comments marked as "MDN" are by Mozilla Contributors, * All doc-comments marked as "MDN" are by Mozilla Contributors,
* distributed under the Creative Commons Attribution-ShareAlike license from * distributed under the Creative Commons Attribution-ShareAlike license from
* https://developer.mozilla.org/en-US/docs/Web/Reference/API * https://developer.mozilla.org/en-US/docs/Web/Reference/API
*/ */
package scala.scalajs.js package scala.scalajs.js
import scala.language.implicitConversions import scala.language.implicitConversions
import scala.scalajs.js
import scala.collection.mutable import scala.collection.mutable
import scala.collection.generic.CanBuildFrom import scala.collection.generic.CanBuildFrom
import annotation.ScalaJSDefined
/** Root of the hierarchy of JavaScript types. /** Root of the hierarchy of JavaScript types.
* *
* Subtypes of [[Any js.Any]] are JavaScript types, which have different * Subtypes of [[Any js.Any]] are JavaScript types, which have different
* semantics and guarantees than Scala types (subtypes of [[AnyRef]] and * semantics and guarantees than Scala types (subtypes of [[AnyRef]] and
* [[AnyVal]]). Operations on JavaScript types behave as the corresponding * [[AnyVal]]). Operations on JavaScript types behave as the corresponding
* operations in the JavaScript language. * operations in the JavaScript language.
* *
* By default, JavaScript types are native: they are facade types to APIs * You can implement JavaScript types in Scala.js. The implementation
* implemented in JavaScript code. Their implementation is irrelevant and * (i.e., the method and constructor bodies) will follow Scala semantics, but
* never emitted. As such, all members must be defined with their * the constructor and methods will be called using JavaScript semantics
* right-hand-side being [[native js.native]]. For forward source * (e.g., runtime dispatch).
* compatibility with the next major version, the class/trait/object itself *
* should be annotated with [[native @js.native]]. This becomes mandatory with * A JavaScript type that is annotated with [[native @js.native]] is a facade
* the compiler option `-P:scalajs:sjsDefinedByDefault`. * type to APIs implemented in JavaScript code. Its implementation is
* irrelevant and never emitted. As such, all members must be defined with
* their right-hand-side being [[native js.native]].
* Further, native JavaScript types must be annotated with one of
* [[annotation.JSGlobal @JSGlobal]], [[annotation.JSImport @JSImport]],
* [[annotation.JSGlobalScope @JSGlobalScope]] to specify where to fetch it
* from.
* *
* In most cases, you should not directly extend this trait, but rather extend * In most cases, you should not directly extend this trait, but rather extend
* [[Object js.Object]]. * [[Object js.Object]].
* *
* To implement a JavaScript type in Scala.js (therefore non-native), you must
* add `-P:scalajs:sjsDefinedByDefault` to your scalac options.
* Scala.js-defined JS types cannot directly extend native JS traits; and
* Scala.js-defined JS traits cannot declare concrete term members.
*
* It is not possible to define traits or classes that inherit both from this * It is not possible to define traits or classes that inherit both from this
* trait and a strict subtype of [[AnyRef]]. In fact, you should think of * trait and a strict subtype of [[AnyRef]]. In fact, you should think of
* [[Any js.Any]] as a third direct subclass of [[scala.Any]], besides * [[Any js.Any]] as a third direct subclass of [[scala.Any]], besides
* [[scala.AnyRef]] and [[scala.AnyVal]]. * [[scala.AnyRef]] and [[scala.AnyVal]].
* *
* See the [[http://www.scala-js.org/doc/js-interoperability.html JavaScript * See the [[http://www.scala-js.org/doc/js-interoperability.html JavaScript
* interoperability guide]] of Scala.js for more details. * interoperability guide]] of Scala.js for more details.
*/ */
trait Any extends scala.AnyRef trait Any extends scala.AnyRef
/** Provides implicit conversions from Scala values to JavaScript values. */ /** Provides implicit conversions from Scala values to JavaScript values. */
object Any extends LowPrioAnyImplicits { object Any extends js.LowPrioAnyImplicits {
@inline implicit def fromUnit(value: Unit): Any = @inline implicit def fromUnit(value: Unit): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromBoolean(value: Boolean): Any = @inline implicit def fromBoolean(value: Boolean): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromByte(value: Byte): Any = @inline implicit def fromByte(value: Byte): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromShort(value: Short): Any = @inline implicit def fromShort(value: Short): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromInt(value: Int): Any = @inline implicit def fromInt(value: Int): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromLong(value: Long): Any = @inline implicit def fromFloat(value: Float): js.Any =
value.toDouble.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromFloat(value: Float): Any = @inline implicit def fromDouble(value: Double): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromDouble(value: Double): Any = @inline implicit def fromString(s: String): js.Any =
value.asInstanceOf[Any] s.asInstanceOf[js.Any]
@inline implicit def fromString(s: String): Any =
s.asInstanceOf[Any]
implicit def jsArrayOps[A](array: Array[A]): ArrayOps[A] = /* The following overload makes sure that the developer does not
new ArrayOps(array) * inadvertently convert a Long to a Double to fit it in a js.Any.
*/
@deprecated(
"A Long is converted to Double to be cast to js.Any. " +
"This is almost certainly not what you want. " +
"Use `.toDouble` explicitly if you need it.",
"forever")
@inline
implicit def fromLong(value: Long): js.Any =
value.toDouble.asInstanceOf[js.Any]
implicit def jsArrayOps[A](array: js.Array[A]): js.ArrayOps[A] =
new js.ArrayOps(array)
implicit def canBuildFromArray[A]: CanBuildFrom[Array[_], A, Array[A]] = { implicit def canBuildFromArray[A]: CanBuildFrom[Array[_], A, js.Array[A]] = {
@inline @inline
class CanBuildFromArray extends CanBuildFrom[Array[_], A, Array[A]] { class CanBuildFromArray extends CanBuildFrom[Array[_], A, js.Array[A]] {
def apply(from: Array[_]): mutable.Builder[A, Array[A]] = def apply(from: js.Array[_]): mutable.Builder[A, js.Array[A]] =
new ArrayOps[A] new js.ArrayOps[A]
def apply(): mutable.Builder[A, Array[A]] = def apply(): mutable.Builder[A, js.Array[A]] =
new ArrayOps[A] new js.ArrayOps[A]
} }
new CanBuildFromArray new CanBuildFromArray
} }
// scalastyle:off line.size.limit // scalastyle:off line.size.limit
/* identity() is important! It prevents the tail-rec treatment in the absence implicit def fromFunction0[R](f: scala.Function0[R]): js.Function0[R] = () =>
* of SAM treatment. f()
* implicit def fromFunction1[T1, R](f: scala.Function1[T1, R]): js.Function1[T1,
* When compiling without SAM treatment, the implicit expansion results in a R] = (x1: T1) => f(x1)
* self-recursive call to the implicit conversion. Without `identity()`, this implicit def fromFunction2[T1, T2, R](f: scala.Function2[T1, T2, R]): js.Funct
* recursive call is in tail position, and the tailcalls phase will convert ion2[T1, T2, R] = (x1: T1, x2: T2) => f(x1, x2)
* it into an infinite loop. implicit def fromFunction3[T1, T2, T3, R](f: scala.Function3[T1, T2, T3, R]):
* js.Function3[T1, T2, T3, R] = (x1: T1, x2: T2, x3: T3) => f(x1, x2, x3)
* With `identity()`, the recursive call is not in tail position. The implicit def fromFunction4[T1, T2, T3, T4, R](f: scala.Function4[T1, T2, T3, T
* back-end therefore receives a call to the implicit conversion, *which is 4, R]): js.Function4[T1, T2, T3, T4, R] = (x1: T1, x2: T2, x3: T3, x4: T4) => f(
* a primitive*, and therefore applies its primitive treatment, x1, x2, x3, x4)
* short-circuiting the infinite recursion. implicit def fromFunction5[T1, T2, T3, T4, T5, R](f: scala.Function5[T1, T2, T
* 3, T4, T5, R]): js.Function5[T1, T2, T3, T4, T5, R] = (x1: T1, x2: T2, x3: T3, x
* With proper SAM treatment, none of this happens, since there is no 4: T4, x5: T5) => f(x1, x2, x3, x4, x5)
* implicit materialization of a recursive call in the first place. implicit def fromFunction6[T1, T2, T3, T4, T5, T6, R](f: scala.Function6[T1, T
*/ 2, T3, T4, T5, T6, R]): js.Function6[T1, T2, T3, T4, T5, T6, R] = (x1: T1, x2: T
implicit def fromFunction0[R](f: scala.Function0[R]): Function0[R] = identity( 2, x3: T3, x4: T4, x5: T5, x6: T6) => f(x1, x2, x3, x4, x5, x6)
() => f()) implicit def fromFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: scala.Function7[T
implicit def fromFunction1[T1, R](f: scala.Function1[T1, R]): Function1[T1, R] 1, T2, T3, T4, T5, T6, T7, R]): js.Function7[T1, T2, T3, T4, T5, T6, T7, R] = (x
= identity((x1: T1) => f(x1)) 1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => f(x1, x2, x3, x4, x5,
implicit def fromFunction2[T1, T2, R](f: scala.Function2[T1, T2, R]): Function x6, x7)
2[T1, T2, R] = identity((x1: T1, x2: T2) => f(x1, x2)) implicit def fromFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: scala.Functio
implicit def fromFunction3[T1, T2, T3, R](f: scala.Function3[T1, T2, T3, R]): n8[T1, T2, T3, T4, T5, T6, T7, T8, R]): js.Function8[T1, T2, T3, T4, T5, T6, T7,
Function3[T1, T2, T3, R] = identity((x1: T1, x2: T2, x3: T3) => f(x1, x2, x3)) T8, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) => f(
implicit def fromFunction4[T1, T2, T3, T4, R](f: scala.Function4[T1, T2, T3, T x1, x2, x3, x4, x5, x6, x7, x8)
4, R]): Function4[T1, T2, T3, T4, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4) implicit def fromFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: scala.Fun
=> f(x1, x2, x3, x4)) ction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): js.Function9[T1, T2, T3, T4, T5,
implicit def fromFunction5[T1, T2, T3, T4, T5, R](f: scala.Function5[T1, T2, T T6, T7, T8, T9, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x
3, T4, T5, R]): Function5[T1, T2, T3, T4, T5, R] = identity((x1: T1, x2: T2, x3: 8: T8, x9: T9) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9)
T3, x4: T4, x5: T5) => f(x1, x2, x3, x4, x5)) implicit def fromFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: sca
implicit def fromFunction6[T1, T2, T3, T4, T5, T6, R](f: scala.Function6[T1, T la.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): js.Function10[T1, T2
2, T3, T4, T5, T6, R]): Function6[T1, T2, T3, T4, T5, T6, R] = identity((x1: T1, , T3, T4, T5, T6, T7, T8, T9, T10, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5,
x2: T2, x3: T3, x4: T4, x5: T5, x6: T6) => f(x1, x2, x3, x4, x5, x6)) x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => f(x1, x2, x3, x4, x5, x6, x7, x8,
implicit def fromFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: scala.Function7[T x9, x10)
1, T2, T3, T4, T5, T6, T7, R]): Function7[T1, T2, T3, T4, T5, T6, T7, R] = ident implicit def fromFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f
ity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7) => f(x1, x2, x3, x4 : scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): js.Functio
, x5, x6, x7)) n11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = (x1: T1, x2: T2, x3: T3,
implicit def fromFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: scala.Functio x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => f(x1, x2,
n8[T1, T2, T3, T4, T5, T6, T7, T8, R]): Function8[T1, T2, T3, T4, T5, T6, T7, T8 x3, x4, x5, x6, x7, x8, x9, x10, x11)
, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8) implicit def fromFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
=> f(x1, x2, x3, x4, x5, x6, x7, x8)) R](f: scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]):
implicit def fromFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: scala.Fun js.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = (x1: T1, x
ction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): Function9[T1, T2, T3, T4, T5, T6 2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T1
, T7, T8, T9, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: 1, x12: T12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)
T7, x8: T8, x9: T9) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9)) implicit def fromFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
implicit def fromFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: sca T13, R](f: scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
la.Function10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): Function10[T1, T2, T T13, R]): js.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
3, T4, T5, T6, T7, T8, T9, T10, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x1
5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10) => f(x1, x2, x3, x4, x5, x6, x7 0: T10, x11: T11, x12: T12, x13: T13) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x
, x8, x9, x10)) 10, x11, x12, x13)
implicit def fromFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f implicit def fromFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
: scala.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): Function11 T13, T14, R](f: scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = identity((x1: T1, x2: T2, x3 T12, T13, T14, R]): js.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11) => f(x T12, T13, T14, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8:
1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => f(x1, x2, x3,
implicit def fromFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)
R](f: scala.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): implicit def fromFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = identity((x1: T13, T14, T15, R](f: scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x T11, T12, T13, T14, T15, R]): js.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9,
11: T11, x12: T12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) T10, T11, T12, T13, T14, T15, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6:
implicit def fromFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x1
T13, R](f: scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 5: T15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)
T13, R]): Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] implicit def fromFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
= identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T13, T14, T15, T16, R](f: scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9,
T9, x10: T10, x11: T11, x12: T12, x13: T13) => f(x1, x2, x3, x4, x5, x6, x7, x8, T10, T11, T12, T13, T14, T15, T16, R]): js.Function16[T1, T2, T3, T4, T5, T6, T7
x9, x10, x11, x12, x13)) , T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = (x1: T1, x2: T2, x3: T3, x4: T
implicit def fromFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T1
T13, T14, R](f: scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, 3, x14: T14, x15: T15, x16: T16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x
T12, T13, T14, R]): Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 11, x12, x13, x14, x15, x16)
, T13, T14, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T implicit def fromFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14) => f(x1, x2 T13, T14, T15, T16, T17, R](f: scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8,
, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): js.Function17[T1, T2, T3, T4,
implicit def fromFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = (x1: T1, x2: T2
T13, T14, T15, R](f: scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, , x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x1
T11, T12, T13, T14, T15, R]): Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 2: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => f(x1, x2, x3, x4, x
, T11, T12, T13, T14, T15, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5 5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)
, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T implicit def fromFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
14, x15: T15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, T13, T14, T15, T16, T17, T18, R](f: scala.Function18[T1, T2, T3, T4, T5, T6, T7
x15)) , T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): js.Function18[T1, T2
implicit def fromFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, , T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] =
T13, T14, T15, T16, R](f: scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T1
T10, T11, T12, T13, T14, T15, T16, R]): Function16[T1, T2, T3, T4, T5, T6, T7, T 0, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T1
8, T9, T10, T11, T12, T13, T14, T15, T16, R] = identity((x1: T1, x2: T2, x3: T3, 8) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x
x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x 17, x18)
13: T13, x14: T14, x15: T15, x16: T16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, implicit def fromFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
x10, x11, x12, x13, x14, x15, x16)) T13, T14, T15, T16, T17, T18, T19, R](f: scala.Function19[T1, T2, T3, T4, T5, T
implicit def fromFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): js.Functio
T13, T14, T15, T16, T17, R](f: scala.Function17[T1, T2, T3, T4, T5, T6, T7, T8, n19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17,
T9, T10, T11, T12, T13, T14, T15, T16, T17, R]): Function17[T1, T2, T3, T4, T5, T18, T19, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8,
T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = identity((x1: T1, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x1
x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T 7: T17, x18: T18, x19: T19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x
11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17) => f(x1, x2, x3, 12, x13, x14, x15, x16, x17, x18, x19)
x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) implicit def fromFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
implicit def fromFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R](f: scala.Function20[T1, T2, T3, T4,
T13, T14, T15, T16, T17, T18, R](f: scala.Function18[T1, T2, T3, T4, T5, T6, T7 T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]):
, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): Function18[T1, T2, T js.Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15,
3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = ide T16, T17, T18, T19, T20, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x
ntity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x 7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T1
10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x 5, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => f(x1, x2, x3, x4, x5, x6
18: T18) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, , x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)
x16, x17, x18)) implicit def fromFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
implicit def fromFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: scala.Function21[T1, T2, T3,
T13, T14, T15, T16, T17, T18, T19, R](f: scala.Function19[T1, T2, T3, T4, T5, T T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20,
6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): Function19 T21, R]): js.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18 T14, T15, T16, T17, T18, T19, T20, T21, R] = (x1: T1, x2: T2, x3: T3, x4: T4, x5
, T19, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8 : T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x1
: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x15: T15, x16: T 4: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T21) =>
16, x17: T17, x18: T18, x19: T19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x
x11, x12, x13, x14, x15, x16, x17, x18, x19)) 18, x19, x20, x21)
implicit def fromFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, implicit def fromFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
T13, T14, T15, T16, T17, T18, T19, T20, R](f: scala.Function20[T1, T2, T3, T4, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: scala.Function22[T1, T2
T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): , T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19,
Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16 T20, T21, T22, R]): js.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
, T17, T18, T19, T20, R] = identity((x1: T1, x2: T2, x3: T3, x4: T4, x5: T5, x6: T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = (x1: T1, x2: T2, x3:
T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T13, x14: T14, x T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T1
15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20) => f(x1, x2, x3, x4, 2, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T2
x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)) 0, x21: T21, x22: T22) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x
implicit def fromFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 13, x14, x15, x16, x17, x18, x19, x20, x21, x22)
T13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: scala.Function21[T1, T2, T3,
T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, implicit def toFunction0[R](f: js.Function0[R]): scala.Function0[R] = () => f(
T21, R]): Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14 )
, T15, T16, T17, T18, T19, T20, T21, R] = identity((x1: T1, x2: T2, x3: T3, x4: implicit def toFunction1[T1, R](f: js.Function1[T1, R]): scala.Function1[T1, R
T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x12: T12, x13: T ] = (x1) => f(x1)
13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x20: T20, x21: T implicit def toFunction2[T1, T2, R](f: js.Function2[T1, T2, R]): scala.Functio
21) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, n2[T1, T2, R] = (x1, x2) => f(x1, x2)
x17, x18, x19, x20, x21)) implicit def toFunction3[T1, T2, T3, R](f: js.Function3[T1, T2, T3, R]): scala
implicit def fromFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, .Function3[T1, T2, T3, R] = (x1, x2, x3) => f(x1, x2, x3)
T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: scala.Function22[T1, T2 implicit def toFunction4[T1, T2, T3, T4, R](f: js.Function4[T1, T2, T3, T4, R]
, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, ): scala.Function4[T1, T2, T3, T4, R] = (x1, x2, x3, x4) => f(x1, x2, x3, x4)
T20, T21, T22, R]): Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 implicit def toFunction5[T1, T2, T3, T4, T5, R](f: js.Function5[T1, T2, T3, T4
, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = identity((x1: T1, x2: T , T5, R]): scala.Function5[T1, T2, T3, T4, T5, R] = (x1, x2, x3, x4, x5) => f(x1
2, x3: T3, x4: T4, x5: T5, x6: T6, x7: T7, x8: T8, x9: T9, x10: T10, x11: T11, x , x2, x3, x4, x5)
12: T12, x13: T13, x14: T14, x15: T15, x16: T16, x17: T17, x18: T18, x19: T19, x implicit def toFunction6[T1, T2, T3, T4, T5, T6, R](f: js.Function6[T1, T2, T3
20: T20, x21: T21, x22: T22) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, , T4, T5, T6, R]): scala.Function6[T1, T2, T3, T4, T5, T6, R] = (x1, x2, x3, x4,
x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)) x5, x6) => f(x1, x2, x3, x4, x5, x6)
implicit def toFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: js.Function7[T1, T2
implicit def toFunction0[R](f: Function0[R]): scala.Function0[R] = () => f() , T3, T4, T5, T6, T7, R]): scala.Function7[T1, T2, T3, T4, T5, T6, T7, R] = (x1,
implicit def toFunction1[T1, R](f: Function1[T1, R]): scala.Function1[T1, R] = x2, x3, x4, x5, x6, x7) => f(x1, x2, x3, x4, x5, x6, x7)
(x1) => f(x1) implicit def toFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: js.Function8[T1
implicit def toFunction2[T1, T2, R](f: Function2[T1, T2, R]): scala.Function2[ , T2, T3, T4, T5, T6, T7, T8, R]): scala.Function8[T1, T2, T3, T4, T5, T6, T7, T
T1, T2, R] = (x1, x2) => f(x1, x2) 8, R] = (x1, x2, x3, x4, x5, x6, x7, x8) => f(x1, x2, x3, x4, x5, x6, x7, x8)
implicit def toFunction3[T1, T2, T3, R](f: Function3[T1, T2, T3, R]): scala.Fu implicit def toFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: js.Function
nction3[T1, T2, T3, R] = (x1, x2, x3) => f(x1, x2, x3) 9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R]): scala.Function9[T1, T2, T3, T4, T5, T
implicit def toFunction4[T1, T2, T3, T4, R](f: Function4[T1, T2, T3, T4, R]): 6, T7, T8, T9, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9) => f(x1, x2, x3, x4, x5
scala.Function4[T1, T2, T3, T4, R] = (x1, x2, x3, x4) => f(x1, x2, x3, x4) , x6, x7, x8, x9)
implicit def toFunction5[T1, T2, T3, T4, T5, R](f: Function5[T1, T2, T3, T4, T implicit def toFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: js.Fu
5, R]): scala.Function5[T1, T2, T3, T4, T5, R] = (x1, x2, x3, x4, x5) => f(x1, x nction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): scala.Function10[T1, T2,
2, x3, x4, x5) T3, T4, T5, T6, T7, T8, T9, T10, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
implicit def toFunction6[T1, T2, T3, T4, T5, T6, R](f: Function6[T1, T2, T3, T => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)
4, T5, T6, R]): scala.Function6[T1, T2, T3, T4, T5, T6, R] = (x1, x2, x3, x4, x5 implicit def toFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f:
, x6) => f(x1, x2, x3, x4, x5, x6) js.Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): scala.Function1
implicit def toFunction7[T1, T2, T3, T4, T5, T6, T7, R](f: Function7[T1, T2, T 1[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = (x1, x2, x3, x4, x5, x6, x7
3, T4, T5, T6, T7, R]): scala.Function7[T1, T2, T3, T4, T5, T6, T7, R] = (x1, x2 , x8, x9, x10, x11) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)
, x3, x4, x5, x6, x7) => f(x1, x2, x3, x4, x5, x6, x7) implicit def toFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R
implicit def toFunction8[T1, T2, T3, T4, T5, T6, T7, T8, R](f: Function8[T1, T ](f: js.Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): scala
2, T3, T4, T5, T6, T7, T8, R]): scala.Function8[T1, T2, T3, T4, T5, T6, T7, T8, .Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = (x1, x2, x3,
R] = (x1, x2, x3, x4, x5, x6, x7, x8) => f(x1, x2, x3, x4, x5, x6, x7, x8) x4, x5, x6, x7, x8, x9, x10, x11, x12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9,
implicit def toFunction9[T1, T2, T3, T4, T5, T6, T7, T8, T9, R](f: Function9[T x10, x11, x12)
1, T2, T3, T4, T5, T6, T7, T8, T9, R]): scala.Function9[T1, T2, T3, T4, T5, T6, implicit def toFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
T7, T8, T9, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9) => f(x1, x2, x3, x4, x5, x 13, R](f: js.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13,
6, x7, x8, x9) R]): scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]
implicit def toFunction10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R](f: Funct = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => f(x1, x2, x3, x4,
ion10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R]): scala.Function10[T1, T2, T3, x5, x6, x7, x8, x9, x10, x11, x12, x13)
T4, T5, T6, T7, T8, T9, T10, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) => implicit def toFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) 13, T14, R](f: js.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
implicit def toFunction11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R](f: T13, T14, R]): scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T1
Function11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R]): scala.Function11[T 2, T13, T14, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)
1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R] = (x1, x2, x3, x4, x5, x6, x7, x => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)
8, x9, x10, x11) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) implicit def toFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
implicit def toFunction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R 13, T14, T15, R](f: js.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11,
](f: Function12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R]): scala.Fu T12, T13, T14, T15, R]): scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T1
nction12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, R] = (x1, x2, x3, x4 0, T11, T12, T13, T14, T15, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11,
, x5, x6, x7, x8, x9, x10, x11, x12) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x1 x12, x13, x14, x15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13,
0, x11, x12) x14, x15)
implicit def toFunction13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T implicit def toFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
13, R](f: Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R]) 13, T14, T15, T16, R](f: js.Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10,
: scala.Function13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, R] = T11, T12, T13, T14, T15, T16, R]): scala.Function16[T1, T2, T3, T4, T5, T6, T7,
(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) => f(x1, x2, x3, x4, x5 T8, T9, T10, T11, T12, T13, T14, T15, T16, R] = (x1, x2, x3, x4, x5, x6, x7, x8,
, x6, x7, x8, x9, x10, x11, x12, x13) x9, x10, x11, x12, x13, x14, x15, x16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9,
implicit def toFunction14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T x10, x11, x12, x13, x14, x15, x16)
13, T14, R](f: Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13 implicit def toFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
, T14, R]): scala.Function14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, 13, T14, T15, T16, T17, R](f: js.Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9,
T13, T14, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) => T10, T11, T12, T13, T14, T15, T16, T17, R]): scala.Function17[T1, T2, T3, T4, T5
f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) , T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = (x1, x2, x3, x4,
implicit def toFunction15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => f(x1, x2, x3, x4,
13, T14, T15, R](f: Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12 x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)
, T13, T14, T15, R]): scala.Function15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, implicit def toFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
T11, T12, T13, T14, T15, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12 13, T14, T15, T16, T17, T18, R](f: js.Function18[T1, T2, T3, T4, T5, T6, T7, T8,
, x13, x14, x15) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x1 T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): scala.Function18[T1, T2,
4, x15) T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = (x
implicit def toFunction16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T 1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)
13, T14, T15, T16, R](f: Function16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11 => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17,
, T12, T13, T14, T15, T16, R]): scala.Function16[T1, T2, T3, T4, T5, T6, T7, T8, x18)
T9, T10, T11, T12, T13, T14, T15, T16, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9 implicit def toFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
, x10, x11, x12, x13, x14, x15, x16) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x1 13, T14, T15, T16, T17, T18, T19, R](f: js.Function19[T1, T2, T3, T4, T5, T6, T7
0, x11, x12, x13, x14, x15, x16) , T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): scala.Function1
implicit def toFunction17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T 9[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T1
13, T14, T15, T16, T17, R](f: Function17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10 8, T19, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15,
, T11, T12, T13, T14, T15, T16, T17, R]): scala.Function17[T1, T2, T3, T4, T5, T x16, x17, x18, x19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13,
6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, R] = (x1, x2, x3, x4, x5, x14, x15, x16, x17, x18, x19)
x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) => f(x1, x2, x3, x4, x5 implicit def toFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) 13, T14, T15, T16, T17, T18, T19, T20, R](f: js.Function20[T1, T2, T3, T4, T5, T
implicit def toFunction18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T 6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): scala
13, T14, T15, T16, T17, T18, R](f: Function18[T1, T2, T3, T4, T5, T6, T7, T8, T9 .Function20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T1
, T10, T11, T12, T13, T14, T15, T16, T17, T18, R]): scala.Function18[T1, T2, T3, 6, T17, T18, T19, T20, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, R] = (x1, x13, x14, x15, x16, x17, x18, x19, x20) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9,
x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) => x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)
f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x1 implicit def toFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
8) 13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: js.Function21[T1, T2, T3, T4,
implicit def toFunction19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21,
13, T14, T15, T16, T17, T18, T19, R](f: Function19[T1, T2, T3, T4, T5, T6, T7, T R]): scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T1
8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, R]): scala.Function19[T 4, T15, T16, T17, T18, T19, T20, T21, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9,
1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => f(x1, x2, x3, x4,
T19, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16 x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)
, x17, x18, x19) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x1 implicit def toFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
4, x15, x16, x17, x18, x19) 13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: js.Function22[T1, T2, T3,
implicit def toFunction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20,
13, T14, T15, T16, T17, T18, T19, T20, R](f: Function20[T1, T2, T3, T4, T5, T6, T21, T22, R]): scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T1
T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, R]): scala.Fu 2, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = (x1, x2, x3, x4, x5, x
nction20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, 6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)
T17, T18, T19, T20, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13 => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17,
, x14, x15, x16, x17, x18, x19, x20) => f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x1 x18, x19, x20, x21, x22)
0, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)
implicit def toFunction21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
13, T14, T15, T16, T17, T18, T19, T20, T21, R](f: Function21[T1, T2, T3, T4, T5,
T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, R])
: scala.Function21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14,
T15, T16, T17, T18, T19, T20, T21, R] = (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10
, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) => f(x1, x2, x3, x4, x5
, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)
implicit def toFunction22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T
13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R](f: Function22[T1, T2, T3, T4
, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21
, T22, R]): scala.Function22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12,
T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, R] = (x1, x2, x3, x4, x5, x6,
x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) =>
f(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x1
8, x19, x20, x21, x22)
// scalastyle:on line.size.limit // scalastyle:on line.size.limit
@inline implicit def fromJBoolean(value: java.lang.Boolean): Any = @inline implicit def fromJBoolean(value: java.lang.Boolean): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromJByte(value: java.lang.Byte): Any = @inline implicit def fromJByte(value: java.lang.Byte): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromJShort(value: java.lang.Short): Any = @inline implicit def fromJShort(value: java.lang.Short): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromJInteger(value: java.lang.Integer): Any = @inline implicit def fromJInteger(value: java.lang.Integer): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromJLong(value: java.lang.Long): Any = /* The following overload makes sure that the developer does not
* inadvertently convert a Long to a Double to fit it in a js.Any.
*/
@deprecated(
"A Long is converted to Double to be cast to js.Any. " +
"This is almost certainly not what you want. " +
"Use `.toDouble` explicitly if you need it.",
"forever")
@inline
implicit def fromJLong(value: java.lang.Long): js.Any =
if (value eq null) null if (value eq null) null
else value.doubleValue.asInstanceOf[Any] else value.doubleValue.asInstanceOf[js.Any]
@inline implicit def fromJFloat(value: java.lang.Float): Any = @inline implicit def fromJFloat(value: java.lang.Float): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
@inline implicit def fromJDouble(value: java.lang.Double): Any = @inline implicit def fromJDouble(value: java.lang.Double): js.Any =
value.asInstanceOf[Any] value.asInstanceOf[js.Any]
implicit class ObjectCompanionOps private[Any] (
private val self: js.Object.type)
extends AnyVal {
/** Tests whether the specified object `o` has a property `p` on itself or
* in its prototype chain.
*
* This method is the equivalent of `p in o` in JavaScript.
*/
def hasProperty(o: js.Object, p: String): Boolean =
js.special.in(p, o)
/** Returns the names of all the enumerable properties of the specified
* object `o`, including properties in its prototype chain.
*
* This method returns the same set of names that would be enumerated by
* a for-in loop in JavaScript, in the same order.
*
* This method assumes that all keys enumerated by a for-in loop are
* strings. If this is not the case, calling this method is an undefined
* behavior of kind `ClassCastException`. Note that for all *ordinary*
* objects, the ECMAScript 2015 guarantees that this is the case. It might
* be false if `o` is a proxy object or another exotic object.
*
* For ordinary objects, if the underlying implementation guarantees an
* order for for-in loops, then this is guaranteed to be consistent with
* [[js.Object.keys]], in the sense that the list returned by
* [[js.Object.keys]] is a sublist of the list returned by this method
* (not just a subset).
*/
@noinline
def properties(o: js.Any): js.Array[String] = {
/* DO NOT touch this code without double-checking the optimized code.
*
* This implementation is carefully crafted so that the optimizer turns
* the code into a pattern known not to fall off the performance cliffs.
*/
val result = js.Array[scala.Any]()
@inline def appendProp(p: scala.Any): Unit = result.push(p)
js.special.forin(o) { p =>
appendProp(p)
}
result.asInstanceOf[js.Array[String]]
}
}
} }
trait LowPrioAnyImplicits extends LowestPrioAnyImplicits { sealed trait LowPrioAnyImplicits extends js.LowestPrioAnyImplicits {
implicit def wrapArray[A](array: Array[A]): WrappedArray[A] = this: js.Any.type =>
new WrappedArray(array)
implicit def wrapDictionary[A](dict: Dictionary[A]): WrappedDictionary[A] = implicit def wrapArray[A](array: js.Array[A]): js.WrappedArray[A] =
new WrappedDictionary(dict) new js.WrappedArray(array)
implicit def wrapDictionary[A](dict: js.Dictionary[A]): js.WrappedDictionary[A
] =
new js.WrappedDictionary(dict)
} }
sealed trait LowestPrioAnyImplicits { sealed trait LowestPrioAnyImplicits {
implicit def iterableOps[A](iterable: Iterable[A]): IterableOps[A] = this: js.Any.type =>
new IterableOps(iterable)
implicit def iterableOps[A](iterable: js.Iterable[A]): js.IterableOps[A] =
new js.IterableOps(iterable)
} }
 End of changes. 15 change blocks. 
300 lines changed or deleted 355 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)