Si no importé nada más que los valores predeterminados habituales de Scala, ¿cuántas implicaciones (conversiones implícitas) están dentro del alcance?¿Cuántas implicidades hay en Scala?
¿Hay una lista completa de ellos en algún lugar, preferiblemente organizados por tipo que podrían actuar?
Scala 2.9.1 tiene 96 implícitos, la mayoría de ellos conversiones, importados por defecto. Tenga en cuenta que hay otras implicidades que no aparecen, porque están definidas en compañeros de objeto para una clase en particular. Por ejemplo, hay un implícito Ordering[T] => Ordering[Iterable[T]] que no aparece a continuación, porque está definido en el objeto complementario de Ordering.
Welcome to Scala version 2.9.1.final (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_26).
Type in expressions to have them evaluated.
Type :help for more information.
scala> :implicits
No implicits have been imported other than those in Predef.
scala> :implicits -v
/* 96 implicit members imported from scala.Predef */
/* 66 inherited from scala.Predef */
implicit def Double2double(x: jl.Double): Double
implicit def byte2double(x: Byte): Double
implicit def char2double(x: Char): Double
implicit def float2double(x: Float): Double
implicit def int2double(x: Int): Double
implicit def long2double(x: Long): Double
implicit def short2double(x: Short): Double
implicit def Float2float(x: jl.Float): Float
implicit def byte2float(x: Byte): Float
implicit def char2float(x: Char): Float
implicit def int2float(x: Int): Float
implicit def long2float(x: Long): Float
implicit def short2float(x: Short): Float
implicit def Integer2int(x: jl.Integer): Int
implicit def byte2int(x: Byte): Int
implicit def char2int(x: Char): Int
implicit def short2int(x: Short): Int
implicit def Long2long(x: jl.Long): Long
implicit def byte2long(x: Byte): Long
implicit def char2long(x: Char): Long
implicit def int2long(x: Int): Long
implicit def short2long(x: Short): Long
implicit def boolean2BooleanConflict(x: Boolean): jl.Object
implicit def byte2ByteConflict(x: Byte): jl.Object
implicit def char2CharacterConflict(x: Char): jl.Object
implicit def double2DoubleConflict(x: Double): jl.Object
implicit def float2FloatConflict(x: Float): jl.Object
implicit def int2IntegerConflict(x: Int): jl.Object
implicit def long2LongConflict(x: Long): jl.Object
implicit def short2ShortConflict(x: Short): jl.Object
implicit def booleanArrayOps(xs: Array[Boolean]): mutable.ArrayOps[Boolean]
implicit def byteArrayOps(xs: Array[Byte]): mutable.ArrayOps[Byte]
implicit def charArrayOps(xs: Array[Char]): mutable.ArrayOps[Char]
implicit def doubleArrayOps(xs: Array[Double]): mutable.ArrayOps[Double]
implicit def floatArrayOps(xs: Array[Float]): mutable.ArrayOps[Float]
implicit def genericArrayOps[T](xs: Array[T]): mutable.ArrayOps[T]
implicit def intArrayOps(xs: Array[Int]): mutable.ArrayOps[Int]
implicit def longArrayOps(xs: Array[Long]): mutable.ArrayOps[Long]
implicit def refArrayOps[T <: AnyRef](xs: Array[T]): mutable.ArrayOps[T]
implicit def shortArrayOps(xs: Array[Short]): mutable.ArrayOps[Short]
implicit def unitArrayOps(xs: Array[Unit]): mutable.ArrayOps[Unit]
implicit def Boolean2boolean(x: jl.Boolean): Boolean
implicit def Byte2byte(x: jl.Byte): Byte
implicit def Character2char(x: jl.Character): Char
implicit def Short2short(x: jl.Short): Short
implicit def any2ArrowAssoc[A](x: A): ArrowAssoc[A]
implicit def any2Ensuring[A](x: A): Ensuring[A]
implicit def any2stringadd(x: Any): runtime.StringAdd
implicit def arrayToCharSequence(xs: Array[Char]): jl.CharSequence
implicit def augmentString(x: String): immutable.StringOps
implicit def boolean2Boolean(x: Boolean): jl.Boolean
implicit def byte2Byte(x: Byte): jl.Byte
implicit def byte2short(x: Byte): Short
implicit def char2Character(x: Char): jl.Character
implicit def conforms[A]: <:<[A,A]
implicit def double2Double(x: Double): jl.Double
implicit def exceptionWrapper(exc: Throwable): runtime.RichException
implicit def float2Float(x: Float): jl.Float
implicit def int2Integer(x: Int): jl.Integer
implicit def long2Long(x: Long): jl.Long
implicit def seqToCharSequence(xs: IndexedSeq[Char]): jl.CharSequence
implicit def short2Short(x: Short): jl.Short
implicit def stringCanBuildFrom: generic.CanBuildFrom[String,Char,String]
implicit def unaugmentString(x: immutable.StringOps): String
implicit def zipped2ToTraversable[El1,El2](zz: (_$1, _$2)#Zipped[_, El1, _, El2]): Traversable[(El1, El2)]
implicit def zipped3ToTraversable[El1,El2,El3](zz: (_$5, _$6, _$7)#Zipped[_, El1, _, El2, _, El3]): Traversable[(El1, El2, El3)]
/* 30 inherited from scala.LowPriorityImplicits */
implicit def genericWrapArray[T](xs: Array[T]): mutable.WrappedArray[T]
implicit def wrapBooleanArray(xs: Array[Boolean]): mutable.WrappedArray[Boolean]
implicit def wrapByteArray(xs: Array[Byte]): mutable.WrappedArray[Byte]
implicit def wrapCharArray(xs: Array[Char]): mutable.WrappedArray[Char]
implicit def wrapDoubleArray(xs: Array[Double]): mutable.WrappedArray[Double]
implicit def wrapFloatArray(xs: Array[Float]): mutable.WrappedArray[Float]
implicit def wrapIntArray(xs: Array[Int]): mutable.WrappedArray[Int]
implicit def wrapLongArray(xs: Array[Long]): mutable.WrappedArray[Long]
implicit def wrapRefArray[T <: AnyRef](xs: Array[T]): mutable.WrappedArray[T]
implicit def wrapShortArray(xs: Array[Short]): mutable.WrappedArray[Short]
implicit def wrapUnitArray(xs: Array[Unit]): mutable.WrappedArray[Unit]
implicit def Boolean2booleanNullConflict(x: Null): Boolean
implicit def Byte2byteNullConflict(x: Null): Byte
implicit def Character2charNullConflict(x: Null): Char
implicit def Double2doubleNullConflict(x: Null): Double
implicit def Float2floatNullConflict(x: Null): Float
implicit def Integer2intNullConflict(x: Null): Int
implicit def Long2longNullConflict(x: Null): Long
implicit def Short2shortNullConflict(x: Null): Short
implicit def booleanWrapper(x: Boolean): runtime.RichBoolean
implicit def byteWrapper(x: Byte): runtime.RichByte
implicit def charWrapper(c: Char): runtime.RichChar
implicit def doubleWrapper(x: Double): runtime.RichDouble
implicit def fallbackStringCanBuildFrom[T]: generic.CanBuildFrom[String,T,immutable.IndexedSeq[T]]
implicit def floatWrapper(x: Float): runtime.RichFloat
implicit def intWrapper(x: Int): runtime.RichInt
implicit def longWrapper(x: Long): runtime.RichLong
implicit def shortWrapper(x: Short): runtime.RichShort
implicit def unwrapString(ws: immutable.WrappedString): String
implicit def wrapString(s: String): immutable.WrappedString
Y, sólo por el gusto de hacerlo, Scalaz añade otro 144:
scala> import scalaz._
import scalaz._
scala> import Scalaz._
import Scalaz._
scala> :implicits
/* 144 implicit members imported from scalaz.Scalaz */
/* 1 inherited from scalaz.ZipStreams */
implicit def ZipStreamFrom[A](z: scalaz.ZipStream[A]): Stream[A]
/* 11 inherited from scalaz.Tuples */
implicit def ToTuple10W[A,B,C,D,E,F,G,H,I,J](t: (A, B, C, D, E, F, G, H, I, J)): Tuple10W[A,B,C,D,E,F,G,H,I,J]
implicit def ToTuple11W[A,B,C,D,E,F,G,H,I,J,K](t: (A, B, C, D, E, F, G, H, I, J, K)): Tuple11W[A,B,C,D,E,F,G,H,I,J,K]
implicit def ToTuple12W[A,B,C,D,E,F,G,H,I,J,K,L](t: (A, B, C, D, E, F, G, H, I, J, K, L)): Tuple12W[A,B,C,D,E,F,G,H,I,J,K,L]
implicit def ToTuple2W[A,B](t: (A, B)): Tuple2W[A,B]
implicit def ToTuple3W[A,B,C](t: (A, B, C)): Tuple3W[A,B,C]
implicit def ToTuple4W[A,B,C,D](t: (A, B, C, D)): Tuple4W[A,B,C,D]
implicit def ToTuple5W[A,B,C,D,E](t: (A, B, C, D, E)): Tuple5W[A,B,C,D,E]
implicit def ToTuple6W[A,B,C,D,E,F](t: (A, B, C, D, E, F)): Tuple6W[A,B,C,D,E,F]
implicit def ToTuple7W[A,B,C,D,E,F,G](t: (A, B, C, D, E, F, G)): Tuple7W[A,B,C,D,E,F,G]
implicit def ToTuple8W[A,B,C,D,E,F,G,H](t: (A, B, C, D, E, F, G, H)): Tuple8W[A,B,C,D,E,F,G,H]
implicit def ToTuple9W[A,B,C,D,E,F,G,H,I](t: (A, B, C, D, E, F, G, H, I)): Tuple9W[A,B,C,D,E,F,G,H,I]
/* 1 inherited from scalaz.Strings */
implicit def StringTo(ss: String): scalaz.StringW
/* 1 inherited from scalaz.Streams */
implicit def StreamTo[A](as: Stream[A]): scalaz.StreamW[A]
/* 1 inherited from scalaz.Shorts */
implicit def ShortTo(n: Short): scalaz.ShortW
/* 3 inherited from scalaz.FingerTree$Ropes */
implicit def unwrapRope[A](wrappedRope: Ropes.this.WrappedRope[A])(implicit evidence$13: ClassManifest[A]): Ropes.this.Rope[A]
implicit def wrapRope[A](rope: Ropes.this.Rope[A])(implicit evidence$12: ClassManifest[A]): Ropes.this.WrappedRope[A]
implicit def wrapRopeChar(rope: Ropes.this.Rope[Char]): Ropes.this.RopeCharW
/* 1 inherited from scalaz.Reducers */
implicit def ReducerMonoid[C,M](r: scalaz.Reducer[C,M]): scalaz.Monoid[M]
/* 1 inherited from scalaz.Options */
implicit def OptionTo[A](o: Option[A]): scalaz.OptionW[A]
/* 55 inherited from scalaz.Names */
implicit def nameToCallable[A]: scalaz.Name[A] => java.util.concurrent.Callable[A]
implicit def nameToConst[A,B](implicit evidence$2: scalaz.Monoid[B]): scalaz.Name[A] => scalaz.Const[B,A]
implicit def nameToEitherLeft[A,X]: scalaz.Name[A] => Either.LeftProjection[A,X]
implicit def nameToEitherRight[A,X]: scalaz.Name[A] => Either.RightProjection[X,A]
implicit def nameToEndo[A]: scalaz.Name[A] => scalaz.Endo[A]
implicit def nameToEphemeralStream[A]: scalaz.Name[A] => scalaz.EphemeralStream[A]
implicit def nameToFirstOption[A]: scalaz.Name[A] => scalaz.FirstOption[A]
implicit def nameToFunction0[A]: scalaz.Name[A] =>() => A
implicit def nameToFunction1[A,R]: scalaz.Name[A] => R => A
implicit def nameToFunction2[A,R,S]: scalaz.Name[A] => (R, S) => A
implicit def nameToFunction3[A,R,S,T]: scalaz.Name[A] => (R, S, T) => A
implicit def nameToFunction4[A,R,S,T,U]: scalaz.Name[A] => (R, S, T, U) => A
implicit def nameToFunction5[A,R,S,T,U,V]: scalaz.Name[A] => (R, S, T, U, V) => A
implicit def nameToFunction6[A,R,S,T,U,V,W]: scalaz.Name[A] => (R, S, T, U, V, W) => A
implicit def nameToIdentity[A]: scalaz.Name[A] => scalaz.Identity[A]
implicit def nameToIterV[A,E]: scalaz.Name[A] => scalaz.IterV[E,A]
implicit def nameToJavaArrayBlockingQueue[A]: scalaz.Name[A] => java.util.concurrent.ArrayBlockingQueue[A]
implicit def nameToJavaArrayList[A]: scalaz.Name[A] => java.util.ArrayList[A]
implicit def nameToJavaConcurrentLinkedQueue[A]: scalaz.Name[A] => java.util.concurrent.ConcurrentLinkedQueue[A]
implicit def nameToJavaCopyOnWriteArrayList[A]: scalaz.Name[A] => java.util.concurrent.CopyOnWriteArrayList[A]
implicit def nameToJavaCopyOnWriteArraySet[A]: scalaz.Name[A] => java.util.concurrent.CopyOnWriteArraySet[A]
implicit def nameToJavaHashSet[A]: scalaz.Name[A] => java.util.HashSet[A]
implicit def nameToJavaLinkedBlockingQueue[A]: scalaz.Name[A] => java.util.concurrent.LinkedBlockingQueue[A]
implicit def nameToJavaLinkedHashSet[A]: scalaz.Name[A] => java.util.LinkedHashSet[A]
implicit def nameToJavaLinkedList[A]: scalaz.Name[A] => java.util.LinkedList[A]
implicit def nameToJavaPriorityQueue[A]: scalaz.Name[A] => java.util.PriorityQueue[A]
implicit def nameToJavaStack[A]: scalaz.Name[A] => java.util.Stack[A]
implicit def nameToJavaSynchronousQueue[A]: scalaz.Name[A] => java.util.concurrent.SynchronousQueue[A]
implicit def nameToJavaTreeSet[A]: scalaz.Name[A] => java.util.TreeSet[A]
implicit def nameToJavaVector[A]: scalaz.Name[A] => java.util.Vector[A]
implicit def nameToLastOption[A]: scalaz.Name[A] => scalaz.LastOption[A]
implicit def nameToLazyOption[A]: scalaz.Name[A] => scalaz.LazyOption[A]
implicit def nameToList[A]: scalaz.Name[A] => List[A]
implicit def nameToMapEntry[A,X](implicit evidence$3: scalaz.Zero[X]): scalaz.Name[A] => java.util.Map.Entry[X,A]
implicit def nameToNonEmptyList[A]: scalaz.Name[A] => scalaz.NonEmptyList[A]
implicit def nameToOption[A]: scalaz.Name[A] => Option[A]
implicit def nameToPromise[A](implicit s: scalaz.concurrent.Strategy): scalaz.Name[A] => scalaz.concurrent.Promise[A]
implicit def nameToResponder[A]: scalaz.Name[A] => Responder[A]
implicit def nameToState[A,S]: scalaz.Name[A] => scalaz.State[S,A]
implicit def nameToStream[A]: scalaz.Name[A] => Stream[A]
implicit def nameToTree[A]: scalaz.Name[A] => scalaz.Tree[A]
implicit def nameToTreeLoc[A]: scalaz.Name[A] => scalaz.TreeLoc[A]
implicit def nameToTuple1[A]: scalaz.Name[A] => (A,)
implicit def nameToTuple2[A,R](implicit evidence$5: scalaz.Zero[R]): scalaz.Name[A] => (R, A)
implicit def nameToTuple3[A,R,S](implicit evidence$6: scalaz.Zero[R],implicit evidence$7: scalaz.Zero[S]): scalaz.Name[A] => (R, S, A)
implicit def nameToTuple4[A,R,S,T](implicit evidence$8: scalaz.Zero[R],implicit evidence$9: scalaz.Zero[S],implicit evidence$10: scalaz.Zero[T]): scalaz.Name[A] => (R, S, T, A)
implicit def nameToTuple5[A,R,S,T,U](implicit evidence$11: scalaz.Zero[R],implicit evidence$12: scalaz.Zero[S],implicit evidence$13: scalaz.Zero[T],implicit evidence$14: scalaz.Zero[U]): scalaz.Name[A] => (R, S, T, U, A)
implicit def nameToTuple6[A,R,S,T,U,V](implicit evidence$15: scalaz.Zero[R],implicit evidence$16: scalaz.Zero[S],implicit evidence$17: scalaz.Zero[T],implicit evidence$18: scalaz.Zero[U],implicit evidence$19: scalaz.Zero[V]): scalaz.Name[A] => (R, S, T, U, V, A)
implicit def nameToTuple7[A,R,S,T,U,V,W](implicit evidence$20: scalaz.Zero[R],implicit evidence$21: scalaz.Zero[S],implicit evidence$22: scalaz.Zero[T],implicit evidence$23: scalaz.Zero[U],implicit evidence$24: scalaz.Zero[V],implicit evidence$25: scalaz.Zero[W]): scalaz.Name[A] => (R, S, T, U, V, W, A)
implicit def nameToValidation[A,X]: scalaz.Name[A] => scalaz.Validation[X,A]
implicit def nameToValidationFailure[A,X]: scalaz.Name[A] => scalaz.FailProjection[A,X]
implicit def nameToZipStream[A]: scalaz.Name[A] => scalaz.ZipStream[A]
implicit def nameToZipper[A]: scalaz.Name[A] => scalaz.Zipper[A]
implicit def nameToStateT[M[_],S,A](a: scalaz.Name[A])(implicit evidence$4: scalaz.Pure[M]): scalaz.StateT[M,S,A]
implicit def pureName[F[_],A](a: scalaz.Name[A])(implicit p: scalaz.Pure[F]): F[A]
/* 1 inherited from scalaz.MetricSpaces */
implicit def levenshteins: scalaz.MetricSpace[String]
/* 3 inherited from scalaz.MABs */
implicit def CokleisliMAB[M[_],A,B](k: scalaz.Cokleisli[M,A,B]): scalaz.MAB[[α, β]scalaz.Cokleisli[M,α,β],A,B]
implicit def Const2MAB[M,A,B](k: scalaz.Const2[M,A,B]): scalaz.MAB[[α, β]scalaz.Const2[M,α,β],A,B]
implicit def KleisliMAB[M[_],A,B](k: scalaz.Kleisli[M,A,B]): scalaz.MAB[[α, β]scalaz.Kleisli[M,α,β],A,B]
/* 1 inherited from scalaz.MABLow */
implicit def mab[M[_,_],A,B](a: M[A,B]): scalaz.MAB[M,A,B]
/* 29 inherited from scalaz.MAs */
implicit def ConstMA[B,A](c: scalaz.Const[B,A]): scalaz.MA[[α]scalaz.Const[B,α],A]
implicit def EitherLeftMA[X,A](a: Either.LeftProjection[A,X]): scalaz.MA[[α]Either.LeftProjection[α,X],A]
implicit def EitherRightMA[X,A](a: Either.RightProjection[X,A]): scalaz.MA[[α]Either.RightProjection[X,α],A]
implicit def FingerMA[V,A](t: scalaz.Finger[V,A]): scalaz.MA[[α]scalaz.Finger[V,α],A]
implicit def FingerTreeMA[V,A](t: scalaz.FingerTree[V,A]): scalaz.MA[[α]scalaz.FingerTree[V,α],A]
implicit def Function1ApplyMA[A,R](f: A => R): scalaz.MA[[α]A => α,R]
implicit def Function2MA[R,S,A](a: (R, S) => A): scalaz.MA[[α](R, S) => α,A]
implicit def Function3MA[R,S,T,A](a: (R, S, T) => A): scalaz.MA[[α](R, S, T) => α,A]
implicit def Function4MA[R,S,T,U,A](a: (R, S, T, U) => A): scalaz.MA[[α](R, S, T, U) => α,A]
implicit def Function5MA[R,S,T,U,V,A](a: (R, S, T, U, V) => A): scalaz.MA[[α](R, S, T, U, V) => α,A]
implicit def Function6MA[R,S,T,U,V,W,A](a: (R, S, T, U, V, W) => A): scalaz.MA[[α](R, S, T, U, V, W) => α,A]
implicit def IterVMA[A,E](v: scalaz.IterV[E,A]): scalaz.MA[[α]scalaz.IterV[E,α],A]
implicit def KleisliMA[M[_],A,B](k: scalaz.Kleisli[M,A,B]): scalaz.MA[[α]scalaz.Kleisli[M,A,α],B]
implicit def MapEntryMA[X,A](e: java.util.Map.Entry[X,A]): scalaz.MA[[α]java.util.Map.Entry[X,α],A]
implicit def MemoMA[V,A](m: scalaz.Memo[A,V]): scalaz.MA[[α]scalaz.Memo[α,V],A]
implicit def NodeMA[V,A](t: scalaz.Node[V,A]): scalaz.MA[[α]scalaz.Node[V,α],A]
implicit def STMA[S,A](s: scalaz.effects.ST[S,A]): scalaz.MA[[α]scalaz.effects.ST[S,α],A]
implicit def SeqMA[M[X] <: Seq[X],A](l: M[A]): scalaz.MA[M,A]
implicit def SetMA[M[X] <: Set[X],A](s: M[A]): scalaz.MA[M,A]
implicit def StateMA[S,A](s: scalaz.State[S,A]): scalaz.MA[[α]scalaz.State[S,α],A]
implicit def Tuple2MA[R,A](a: (R, A)): scalaz.MA[[α](R, α),A]
implicit def Tuple3MA[R,S,A](a: (R, S, A)): scalaz.MA[[α](R, S, α),A]
implicit def Tuple4MA[R,S,T,A](a: (R, S, T, A)): scalaz.MA[[α](R, S, T, α),A]
implicit def Tuple5MA[R,S,T,U,A](a: (R, S, T, U, A)): scalaz.MA[[α](R, S, T, U, α),A]
implicit def Tuple6MA[R,S,T,U,V,A](a: (R, S, T, U, V, A)): scalaz.MA[[α](R, S, T, U, V, α),A]
implicit def Tuple7MA[R,S,T,U,V,W,A](a: (R, S, T, U, V, W, A)): scalaz.MA[[α](R, S, T, U, V, W, α),A]
implicit def ValidationFailureMA[A,E](f: scalaz.FailProjection[E,A]): scalaz.MA[[α]scalaz.FailProjection[α,A],E]
implicit def ValidationMA[A,E](v: scalaz.Validation[E,A]): scalaz.MA[[α]scalaz.Validation[E,α],A]
implicit def Function1FlipMAContravariant[A,R](f: R => A): scalaz.MAContravariant[[α]α => A,R]
/* 2 inherited from scalaz.MAsLow */
implicit def maContravariantImplicit[M[_],A](a: M[A]): scalaz.MAContravariant[M,A]
implicit def maImplicit[M[_],A](a: M[A]): scalaz.MA[M,A]
/* 1 inherited from scalaz.Longs */
implicit def LongTo(n: Long): scalaz.LongW
/* 1 inherited from scalaz.Lists */
implicit def ListTo[A](as: List[A]): scalaz.ListW[A]
/* 1 inherited from scalaz.LastLazyOptions */
implicit def LastLazyOptionTo[A](a: scalaz.LazyOption[A]): scalaz.LastLazyOption[A]
/* 1 inherited from scalaz.LastOptions */
implicit def LastOptionTo[A](a: Option[A]): scalaz.LastOption[A]
/* 1 inherited from scalaz.Ints */
implicit def IntTo(n: Int): scalaz.IntW
/* 1 inherited from scalaz.InputStreams */
implicit def InputStreamTo(v: java.io.InputStream): scalaz.InputStreamW
/* 2 inherited from scalaz.Identitys */
implicit def mkIdentity[A](x: => A): scalaz.Identity[A]
implicit def unMkIdentity[A](x: scalaz.Identity[A]): A
/* 2 inherited from scalaz.Kleislis */
implicit def kleisliBind[M[_],R](implicit b: scalaz.Bind[M]): scalaz.Bind[[x]scalaz.Kleisli[M,R,x]]
implicit def kleisliFn[M[_],A,B](k: scalaz.Kleisli[M,A,B]): A => M[B]
/* 2 inherited from scalaz.Function2s */
implicit def Function2From[T1,T2,R](f: scalaz.Function2W[T1,T2,R]): (T1, T2) => R
implicit def Function2To[T1,T2,R](f: (T1, T2) => R): scalaz.Function2W[T1,T2,R]
/* 2 inherited from scalaz.Function1s */
implicit def Function1From[T,R](f: scalaz.Function1W[T,R]): T => R
implicit def Function1To[T,R](f: T => R): scalaz.Function1W[T,R]
/* 2 inherited from scalaz.Function0s */
implicit def Function0From[T](f: scalaz.Function0W[T]):() => T
implicit def Function0To[T](f:() => T): scalaz.Function0W[T]
/* 1 inherited from scalaz.FirstLazyOptions */
implicit def LazyFirstOptionTo[A](a: scalaz.LazyOption[A]): scalaz.FirstLazyOption[A]
/* 1 inherited from scalaz.FirstOptions */
implicit def FirstOptionTo[A](a: Option[A]): scalaz.FirstOption[A]
/* 1 inherited from scalaz.Extras */
implicit def natToFunction[F[_],G[_],A](f: scalaz.~>[F,G]): F[A] => G[A]
/* 1 inherited from scalaz.Enumerations */
implicit def EnumerationTo[A](v: java.util.Enumeration[A]): scalaz.EnumerationW[A]
/* 1 inherited from scalaz.Duals */
implicit def DualTo[A](a: A): scalaz.Dual[A]
/* 2 inherited from scalaz.Digits */
implicit def DigitLong(d: scalaz.Digit): Long
implicit def LongDigit(n: Long): scalaz.Digit
/* 1 inherited from scalaz.CharSets */
implicit def CharSetFrom(charSet: scalaz.CharSet): String
/* 1 inherited from scalaz.Chars */
implicit def CharTo(c: Char): scalaz.CharW
/* 1 inherited from scalaz.Bytes */
implicit def ByteTo(n: Byte): scalaz.ByteW
/* 2 inherited from scalaz.Booleans */
implicit def BooleanFrom(b: scalaz.BooleanW): Boolean
implicit def BooleanTo(b: Boolean): scalaz.BooleanW
/* 1 inherited from scalaz.BigInts */
implicit def BigIntTo(n: BigInt): scalaz.BigIntW
/* 1 inherited from scalaz.BigIntegers */
implicit def BigIntegerTo(n: java.math.BigInteger): scalaz.BigIntegerW
/* 1 inherited from scalaz.ArrayBytes */
implicit def ArrayByteTo(bs: Array[Byte]): scalaz.ArrayByte
/* 1 inherited from scalaz.Alphas */
implicit def AlphaChar(a: scalaz.Alpha): Char
/* 1 inherited from scalaz.concurrent.Actors */
implicit def ActorFrom[A](a: scalaz.concurrent.Actor[A]): A => Unit
BUEN POST! Esperemos que más personas usen REPL y: implicits. – jsuereth
@Daniel C. Sobral: Considere agregar un aviso sobre ': implicits' al texto, para que quede claro que se trata de una característica REPL predeterminada. – Henning
Merece la pena señalar que hay un * lote * de otras implicaciones que se activarán en su código sin más importaciones simplemente como resultado del uso de funciones o valores particulares. La biblioteca de colecciones es el mejor ejemplo de esto. –
Todos los implicits predeterminados se pueden encontrar en el objeto scala.Predef y scala.LowPriorityImplicits que se extiende Predef. Todas las demás implicaciones proporcionadas por Scala se encuentran en las clases complementarias de las clases que convierten, que son numerosas y se usan en casi todas las bibliotecas.
Interesante pregunta. Sólo va a tomar algunas notas para mi propio beneficio aquí ...
LowPriorityImplicits tiene implícitos a
WrappedArrayRichBoolean, RichByte, RichChar, ...WrappedString y también para desenvolverloPredef tiene implicits to
ArrayOps que devuelve arrays al aplicar los métodos habituales de coleccionesStringOps y la espaldaCharSequence de la SEC indexada de Char o Array[Char]Predef también tiene implícitos que proporciona funcionalidad que usted pensaría que no es provisto por la biblioteca sino por el idioma:
Byte-Short1 -> "a" con la flecha derechaensuring afirmacionesEntonces hay una CanBuildFrom para String de modo que si se manipulan Char con map/filter/... puede obtener un String, así como uno que le permite obtener un IndexedSeq si Empezaste de una cadena.
Entonces, finalmente, hay implícitas relacionadas con las restricciones de tipo como <:<, =:=.
Ver también: [Cuando-hace-scala-mirada-de-implícitos] (http: // stackoverflow. com/questions/5598085/where-does-scala-look-for-implicits) –