Type Members
-
type
->[A, B] = ~>[[B]A, [B]B]
-
type
:&:[A, B] = LazyTuple2[A, B]
-
type
ArraySeq[A] = scala.collection.mutable.ArraySeq[A]
-
type
Id[A] = A
-
-
trait
Konst[A] extends AnyRef
-
-
-
final
class
RopeBuilder[A] extends Builder[A, Rope[A]]
-
-
type
Thunk[A] = () ⇒ A
-
trait
Tuple10W[A, B, C, D, E, F, G, H, I, J] extends PimpedType[(A, B, C, D, E, F, G, H, I, J)]
-
trait
Tuple11W[A, B, C, D, E, F, G, H, I, J, K] extends PimpedType[(A, B, C, D, E, F, G, H, I, J, K)]
-
trait
Tuple12W[A, B, C, D, E, F, G, H, I, J, K, L] extends PimpedType[(A, B, C, D, E, F, G, H, I, J, K, L)]
-
-
trait
Tuple3W[A, B, C] extends PimpedType[(A, B, C)]
-
trait
Tuple4W[A, B, C, D] extends PimpedType[(A, B, C, D)]
-
trait
Tuple5W[A, B, C, D, E] extends PimpedType[(A, B, C, D, E)]
-
trait
Tuple6W[A, B, C, D, E, F] extends PimpedType[(A, B, C, D, E, F)]
-
trait
Tuple7W[A, B, C, D, E, F, G] extends PimpedType[(A, B, C, D, E, F, G)]
-
trait
Tuple8W[A, B, C, D, E, F, G, H] extends PimpedType[(A, B, C, D, E, F, G, H)]
-
trait
Tuple9W[A, B, C, D, E, F, G, H, I] extends PimpedType[(A, B, C, D, E, F, G, H, I)]
-
-
sealed
class
WrappedRope[A] extends NewType[Rope[A]] with IndexedSeq[A] with IndexedSeqLike[A, WrappedRope[A]]
-
type
ℤ = BigInt
-
type
⊤ = Any
-
type
⊥ = Nothing
Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
<∅>[E[_], A](implicit e: Empty[E]): E[A]
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
implicit
def
ActorFrom[A](a: Actor[A]): (A) ⇒ Unit
-
-
implicit
def
AlphaChar(a: Alpha): Char
-
def
AnyReducer: Reducer[Boolean, Boolean]
-
implicit
def
ArrayByteTo(bs: Array[Byte]): ArrayByte
-
val
ArraySeq: scala.collection.mutable.ArraySeq.type
-
-
implicit
def
BigIntTo(n: BigInt): BigIntW
-
-
implicit
def
BigIntegerTo(n: BigInteger): BigIntegerW
-
implicit
def
BooleanFrom(b: BooleanW): Boolean
-
implicit
def
BooleanTo(b: Boolean): BooleanW
-
-
implicit
def
ByteTo(n: Byte): ByteW
-
-
implicit
def
CharSetFrom(charSet: CharSet): String
-
implicit
def
CharTo(c: Char): CharW
-
implicit
def
CokleisliMAB[M[_], A, B](k: Cokleisli[M, A, B]): MAB[[α, β]Cokleisli[M, α, β], A, B]
-
implicit
def
Const2MAB[M, A, B](k: Const2[M, A, B]): MAB[[α, β]Const2[M, α, β], A, B]
-
implicit
def
ConstMA[B, A](c: Const[B, A]): MA[[α]Const[B, α], A]
-
implicit
def
DigitLong(d: Digit): Long
-
def
DualReducer[A](implicit arg0: Monoid[A]): Reducer[A, Dual[A]]
-
implicit
def
DualTo[A](a: A): Dual[A]
-
implicit
def
EitherLeftMA[X, A](a: LeftProjection[A, X]): MA[[α]LeftProjection[α, X], A]
-
implicit
def
EitherRightMA[X, A](a: RightProjection[X, A]): MA[[α]RightProjection[X, α], A]
-
def
EndoReducer[A]: Reducer[(A) ⇒ A, Endo[A]]
-
def
EndoTo[A](f: (A) ⇒ A): Endo[A]
-
implicit
def
EnumerationTo[A](v: Enumeration[A]): EnumerationW[A]
-
implicit
def
FingerMA[V, A](t: Finger[V, A]): MA[[α]Finger[V, α], A]
-
implicit
def
FingerTreeMA[V, A](t: FingerTree[V, A]): MA[[α]FingerTree[V, α], A]
-
def
FirstOptionReducer[A]: Reducer[Option[A], FirstOption[A]]
-
implicit
def
FirstOptionTo[A](a: Option[A]): FirstOption[A]
-
-
implicit
def
Function0From[T](f: Function0W[T]): () ⇒ T
-
implicit
def
Function0To[T](f: () ⇒ T): Function0W[T]
-
implicit
def
Function1ApplyMA[A, R](f: (A) ⇒ R): MA[[α](A) ⇒ α, R]
-
implicit
def
Function1FlipMAContravariant[A, R](f: (R) ⇒ A): MAContravariant[[α](α) ⇒ A, R]
-
implicit
def
Function1From[T, R](f: Function1W[T, R]): (T) ⇒ R
-
implicit
def
Function1To[T, R](f: (T) ⇒ R): Function1W[T, R]
-
implicit
def
Function2From[T1, T2, R](f: Function2W[T1, T2, R]): (T1, T2) ⇒ R
-
implicit
def
Function2MA[R, S, A](a: (R, S) ⇒ A): MA[[α](R, S) ⇒ α, A]
-
implicit
def
Function2To[T1, T2, R](f: (T1, T2) ⇒ R): Function2W[T1, T2, R]
-
implicit
def
Function3MA[R, S, T, A](a: (R, S, T) ⇒ A): MA[[α](R, S, T) ⇒ α, A]
-
implicit
def
Function4MA[R, S, T, U, A](a: (R, S, T, U) ⇒ A): MA[[α](R, S, T, U) ⇒ α, A]
-
implicit
def
Function5MA[R, S, T, U, V, A](a: (R, S, T, U, V) ⇒ A): 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): MA[[α](R, S, T, U, V, W) ⇒ α, A]
-
def
FunctorBindApply[Z[_]](implicit t: Functor[Z], b: Bind[Z]): Apply[Z]
-
-
-
implicit
def
InputStreamTo(v: InputStream): InputStreamW
-
-
implicit
def
IntTo(n: Int): IntW
-
implicit
def
IterVMA[A, E](v: IterV[E, A]): MA[[α]IterV[E, α], A]
-
implicit
def
KleisliMA[M[_], A, B](k: Kleisli[M, A, B]): MA[[α]Kleisli[M, A, α], B]
-
implicit
def
KleisliMAB[M[_], A, B](k: Kleisli[M, A, B]): MAB[[α, β]Kleisli[M, α, β], A, B]
-
-
def
LastOptionReducer[A]: Reducer[Option[A], LastOption[A]]
-
implicit
def
LastOptionTo[A](a: Option[A]): LastOption[A]
-
-
-
def
ListReducer[C]: Reducer[C, List[C]]
-
implicit
def
ListTo[A](as: List[A]): ListW[A]
-
implicit
def
LongDigit(n: Long): Digit
-
-
implicit
def
LongTo(n: Long): LongW
-
implicit
def
MapEntryMA[X, A](e: Entry[X, A]): MA[[α]Entry[X, α], A]
-
implicit
def
MapMA[K, V](m: Map[K, V]): MA[[α]Map[α, V], K]
-
implicit
def
MemoMA[V, A](m: Memo[A, V]): MA[[α]Memo[α, V], A]
-
-
implicit
def
NodeMA[V, A](t: Node[V, A]): MA[[α]Node[V, α], A]
-
implicit
def
OptionTo[A](o: Option[A]): OptionW[A]
-
def
Reducer[M](implicit arg0: Monoid[M]): Reducer[M, M]
-
def
Reducer[C, M](unit: (C) ⇒ M)(implicit arg0: Monoid[M]): Reducer[C, M]
-
implicit
def
ReducerMonoid[C, M](r: Reducer[C, M]): Monoid[M]
-
-
implicit
def
STMA[S, A](s: ST[S, A]): MA[[α]ST[S, α], A]
-
implicit
def
SeqMA[M[X] <: Seq[X], A](l: M[A]): MA[M, A]
-
implicit
def
SetMA[M[X] <: Set[X], A](s: M[A]): MA[M, A]
-
-
implicit
def
ShortTo(n: Short): ShortW
-
implicit
def
StateMA[S, A](s: State[S, A]): MA[[α]State[S, α], A]
-
def
StreamReducer[C]: Reducer[C, Stream[C]]
-
implicit
def
StreamTo[A](as: Stream[A]): StreamW[A]
-
implicit
def
StringTo(ss: String): StringW
-
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]
-
implicit
def
Tuple2MA[R, A](a: (R, A)): MA[[α](R, α), A]
-
implicit
def
Tuple3MA[R, S, A](a: (R, S, A)): MA[[α](R, S, α), A]
-
implicit
def
Tuple4MA[R, S, T, A](a: (R, S, T, A)): MA[[α](R, S, T, α), A]
-
implicit
def
Tuple5MA[R, S, T, U, A](a: (R, S, T, U, A)): MA[[α](R, S, T, U, α), A]
-
implicit
def
Tuple6MA[R, S, T, U, V, A](a: (R, S, T, U, V, A)): 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)): MA[[α](R, S, T, U, V, W, α), A]
-
-
-
-
-
-
def
UnitReducer[C]: Reducer[C, Unit]
-
implicit
def
ValidationFailureMA[A, E](f: FailProjection[E, A]): MA[[α]FailProjection[α, A], E]
-
implicit
def
ValidationMA[A, E](v: Validation[E, A]): MA[[α]Validation[E, α], A]
-
implicit
def
ZipStreamFrom[A](z: ZipStream[A]): Stream[A]
-
def
actor[A](e: (A) ⇒ Unit, err: (Throwable) ⇒ Unit)(implicit s: Strategy): Actor[A]
-
val
alphas: List[Alpha]
-
def
arrayMemo[V >: Null](n: Int)(implicit arg0: ClassManifest[V]): Memo[Int, V]
-
final
def
asInstanceOf[T0]: T0
-
def
ask[M[_], A](implicit arg0: Monad[M]): Kleisli[M, A, A]
-
def
charset(v: String): CharSet
-
def
clone(): AnyRef
-
def
cokleisli[W[_], A, B](f: (W[A]) ⇒ B): Cokleisli[W, A, B]
-
-
def
constantEndo[A](a: ⇒ A): Endo[A]
-
val
digits: List[Digit]
-
def
doubleArrayMemo(n: Int, sentinel: Double = 0d): Memo[Int, Double]
-
def
effect[A](c: (A) ⇒ Unit)(implicit s: Strategy): Effect[A]
-
def
emptyBKTree[A]: BKTree[A]
-
def
emptyPromise[A](implicit s: Strategy): Promise[A]
-
def
emptyZipStream: ZipStream[Nothing]
-
final
def
eq(arg0: AnyRef): Boolean
-
def
equal[A](f: (A, A) ⇒ Boolean): Equal[A]
-
def
equalA[A]: Equal[A]
-
def
equalBy[A, B](f: (A) ⇒ B)(implicit arg0: Equal[B]): Equal[A]
-
def
equals(arg0: Any): Boolean
-
def
failure[E, A](e: E): Validation[E, A]
-
def
finalize(): Unit
-
def
fromForest[A](ts: Stream[Tree[A]]): Some[TreeLoc[A]]
-
final
def
getClass(): Class[_]
-
def
gets[S, A](f: (S) ⇒ A): State[S, A]
-
def
hashCode(): Int
-
-
def
idEndo[A]: Endo[A]
-
val
idMonad: Monad[Id]
-
def
immutableHashMapMemo[K, V]: Memo[K, V]
-
def
immutableListMapMemo[K, V]: Memo[K, V]
-
def
immutableTreeMapMemo[K, V](implicit arg0: scala.Ordering[K]): Memo[K, V]
-
def
init[S]: State[S, S]
-
final
def
isInstanceOf[T0]: Boolean
-
def
kleisli[M[_], A, B](f: (A) ⇒ M[B]): Kleisli[M, A, B]
-
implicit
def
kleisliBind[M[_], R](implicit b: Bind[M]): Bind[[x]Kleisli[M, R, x]]
-
implicit
def
kleisliFn[M[_], A, B](k: Kleisli[M, A, B]): (A) ⇒ M[B]
-
def
kleisliPure[M[_], R](implicit m: Pure[M]): Pure[[x]Kleisli[M, R, x]]
-
def
lazyTuple[A, B, C, D](a: ⇒ A, b: ⇒ B, c: ⇒ C, d: ⇒ D): LazyTuple4[A, B, C, D]
-
def
lazyTuple[A, B, C](a: ⇒ A, b: ⇒ B, c: ⇒ C): LazyTuple3[A, B, C]
-
def
lazyTuple[A, B](a: ⇒ A, b: ⇒ B): :&:[A, B]
-
def
leaf[A](root: ⇒ A): Tree[A]
-
def
levenshtein[M[_], A](implicit l: Length[M], i: Index[M], e: Equal[A]): MetricSpace[M[A]]
-
implicit
def
levenshteins: MetricSpace[String]
-
def
loc[A](t: Tree[A], l: Stream[Tree[A]], r: Stream[Tree[A]], p: Stream[(Stream[Tree[A]], A, Stream[Tree[A]])]): TreeLoc[A]
-
def
ma[M[_], A](a: M[A]): MA[M, A]
-
def
maContravariant[M[_], A](a: M[A])(implicit cf: Contravariant[M]): MAContravariant[M, A]
-
implicit
def
maContravariantImplicit[M[_], A](a: M[A]): MAContravariant[M, A]
-
implicit
def
maImplicit[M[_], A](a: M[A]): MA[M, A]
-
implicit
def
mab[M[_, _], A, B](a: M[A, B]): MAB[M, A, B]
-
def
memo[K, V](f: ((K) ⇒ V) ⇒ (K) ⇒ V): Memo[K, V]
-
def
metricSpace[A](f: (A, A) ⇒ Int): MetricSpace[A]
-
implicit
def
mkIdentity[A](x: ⇒ A): Identity[A]
-
def
mkLogger[L]: ~>[Id, [α]Logger[L, α]]
-
def
modify[S](f: (S) ⇒ S): State[S, Unit]
-
-
-
-
-
-
-
-
def
mutableHashMapMemo[K, V]: Memo[K, V]
-
def
mzero[Z](implicit z: Zero[Z]): Z
-
implicit
def
nameToCallable[A]: (Name[A]) ⇒ Callable[A]
-
implicit
def
nameToConst[A, B](implicit arg0: Monoid[B]): (Name[A]) ⇒ Const[B, A]
-
implicit
def
nameToEitherLeft[A, X]: (Name[A]) ⇒ LeftProjection[A, X]
-
implicit
def
nameToEitherRight[A, X]: (Name[A]) ⇒ RightProjection[X, A]
-
implicit
def
nameToEndo[A]: (Name[A]) ⇒ Endo[A]
-
implicit
def
nameToEphemeralStream[A]: (Name[A]) ⇒ EphemeralStream[A]
-
implicit
def
nameToFirstOption[A]: (Name[A]) ⇒ FirstOption[A]
-
implicit
def
nameToFunction0[A]: (Name[A]) ⇒ () ⇒ A
-
implicit
def
nameToFunction1[A, R]: (Name[A]) ⇒ (R) ⇒ A
-
implicit
def
nameToFunction2[A, R, S]: (Name[A]) ⇒ (R, S) ⇒ A
-
implicit
def
nameToFunction3[A, R, S, T]: (Name[A]) ⇒ (R, S, T) ⇒ A
-
implicit
def
nameToFunction4[A, R, S, T, U]: (Name[A]) ⇒ (R, S, T, U) ⇒ A
-
implicit
def
nameToFunction5[A, R, S, T, U, V]: (Name[A]) ⇒ (R, S, T, U, V) ⇒ A
-
implicit
def
nameToFunction6[A, R, S, T, U, V, W]: (Name[A]) ⇒ (R, S, T, U, V, W) ⇒ A
-
implicit
def
nameToIdentity[A]: (Name[A]) ⇒ Identity[A]
-
implicit
def
nameToIterV[A, E]: (Name[A]) ⇒ IterV[E, A]
-
implicit
def
nameToJavaArrayBlockingQueue[A]: (Name[A]) ⇒ ArrayBlockingQueue[A]
-
implicit
def
nameToJavaArrayList[A]: (Name[A]) ⇒ ArrayList[A]
-
implicit
def
nameToJavaConcurrentLinkedQueue[A]: (Name[A]) ⇒ ConcurrentLinkedQueue[A]
-
implicit
def
nameToJavaCopyOnWriteArrayList[A]: (Name[A]) ⇒ CopyOnWriteArrayList[A]
-
implicit
def
nameToJavaCopyOnWriteArraySet[A]: (Name[A]) ⇒ CopyOnWriteArraySet[A]
-
implicit
def
nameToJavaHashSet[A]: (Name[A]) ⇒ HashSet[A]
-
implicit
def
nameToJavaLinkedBlockingQueue[A]: (Name[A]) ⇒ LinkedBlockingQueue[A]
-
implicit
def
nameToJavaLinkedHashSet[A]: (Name[A]) ⇒ LinkedHashSet[A]
-
implicit
def
nameToJavaLinkedList[A]: (Name[A]) ⇒ LinkedList[A]
-
implicit
def
nameToJavaPriorityQueue[A]: (Name[A]) ⇒ PriorityQueue[A]
-
implicit
def
nameToJavaStack[A]: (Name[A]) ⇒ Stack[A]
-
implicit
def
nameToJavaSynchronousQueue[A]: (Name[A]) ⇒ SynchronousQueue[A]
-
implicit
def
nameToJavaTreeSet[A]: (Name[A]) ⇒ TreeSet[A]
-
implicit
def
nameToJavaVector[A]: (Name[A]) ⇒ Vector[A]
-
implicit
def
nameToLastOption[A]: (Name[A]) ⇒ LastOption[A]
-
implicit
def
nameToLazyOption[A]: (Name[A]) ⇒ LazyOption[A]
-
implicit
def
nameToList[A]: (Name[A]) ⇒ List[A]
-
implicit
def
nameToMapEntry[A, X](implicit arg0: Zero[X]): (Name[A]) ⇒ Entry[X, A]
-
implicit
def
nameToNonEmptyList[A]: (Name[A]) ⇒ NonEmptyList[A]
-
implicit
def
nameToOption[A]: (Name[A]) ⇒ Option[A]
-
implicit
def
nameToPromise[A](implicit s: Strategy): (Name[A]) ⇒ Promise[A]
-
implicit
def
nameToResponder[A]: (Name[A]) ⇒ Responder[A]
-
implicit
def
nameToState[A, S]: (Name[A]) ⇒ State[S, A]
-
implicit
def
nameToStateT[M[_], S, A](a: Name[A])(implicit arg0: Pure[M]): StateT[M, S, A]
-
implicit
def
nameToStream[A]: (Name[A]) ⇒ Stream[A]
-
def
nameToTraversable[A, CC[X] <: TraversableLike[X, CC[X]]](a: Name[A])(implicit arg0: CanBuildAnySelf[CC]): CC[A]
-
implicit
def
nameToTree[A]: (Name[A]) ⇒ Tree[A]
-
implicit
def
nameToTreeLoc[A]: (Name[A]) ⇒ TreeLoc[A]
-
implicit
def
nameToTuple1[A]: (Name[A]) ⇒ (A)
-
implicit
def
nameToTuple2[A, R](implicit arg0: Zero[R]): (Name[A]) ⇒ (R, A)
-
implicit
def
nameToTuple3[A, R, S](implicit arg0: Zero[R], arg1: Zero[S]): (Name[A]) ⇒ (R, S, A)
-
implicit
def
nameToTuple4[A, R, S, T](implicit arg0: Zero[R], arg1: Zero[S], arg2: Zero[T]): (Name[A]) ⇒ (R, S, T, A)
-
implicit
def
nameToTuple5[A, R, S, T, U](implicit arg0: Zero[R], arg1: Zero[S], arg2: Zero[T], arg3: Zero[U]): (Name[A]) ⇒ (R, S, T, U, A)
-
implicit
def
nameToTuple6[A, R, S, T, U, V](implicit arg0: Zero[R], arg1: Zero[S], arg2: Zero[T], arg3: Zero[U], arg4: Zero[V]): (Name[A]) ⇒ (R, S, T, U, V, A)
-
implicit
def
nameToTuple7[A, R, S, T, U, V, W](implicit arg0: Zero[R], arg1: Zero[S], arg2: Zero[T], arg3: Zero[U], arg4: Zero[V], arg5: Zero[W]): (Name[A]) ⇒ (R, S, T, U, V, W, A)
-
implicit
def
nameToValidation[A, X]: (Name[A]) ⇒ Validation[X, A]
-
implicit
def
nameToValidationFailure[A, X]: (Name[A]) ⇒ FailProjection[A, X]
-
implicit
def
nameToZipStream[A]: (Name[A]) ⇒ ZipStream[A]
-
implicit
def
nameToZipper[A]: (Name[A]) ⇒ Zipper[A]
-
implicit
def
natToFunction[F[_], G[_], A](f: ~>[F, G]): (F[A]) ⇒ G[A]
-
final
def
ne(arg0: AnyRef): Boolean
-
def
nel[A](h: A, t: List[A]): NonEmptyList[A]
-
def
nel[A](h: A, t: A*): NonEmptyList[A]
-
def
nil[A]: List[A]
-
def
nilMemo[K, V]: Memo[K, V]
-
def
node[A](root: ⇒ A, forest: ⇒ Stream[Tree[A]]): Tree[A]
-
def
none[A]: Option[A]
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
optionT[M[_]]: ~>[[α]M[Option[α]], [α]OptionT[M, α]]
-
def
order[A](f: (A, A) ⇒ Ordering): Order[A]
-
def
orderBy[A, B](f: (A) ⇒ B)(implicit arg0: Order[B]): Order[A]
-
def
promise[A](a: ⇒ A)(implicit s: Strategy): Promise[A]
-
def
pure[F[_]](implicit arg0: Pure[F]): ~>[Id, F]
-
implicit
def
pureName[F[_], A](a: Name[A])(implicit p: Pure[F]): F[A]
-
def
put[S](s: S): State[S, Unit]
-
def
resource[T](cl: (T) ⇒ Unit): Resource[T]
-
-
def
semigroup[S](f: (S, ⇒ S) ⇒ S): Semigroup[S]
-
def
show[A](f: (A) ⇒ List[Char]): Show[A]
-
def
showA[A]: Show[A]
-
def
showBy[A, B](f: (A) ⇒ B)(implicit arg0: Show[B]): Show[A]
-
def
shows[A](f: (A) ⇒ String): Show[A]
-
def
some[A](a: A): Option[A]
-
def
state[S, A](f: (S) ⇒ (S, A)): State[S, A]
-
def
stateT[M[_], S, A](f: (S) ⇒ M[(S, A)]): StateT[M, S, A]
-
def
success[E, A](a: A): Validation[E, A]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
implicit
def
unMkIdentity[A](x: Identity[A]): A
-
def
undefined: Nothing
-
val
unital: Identity[Unit]
-
implicit
def
unwrapRope[A](wrappedRope: WrappedRope[A])(implicit arg0: ClassManifest[A]): Rope[A]
-
def
validation[E, A](e: Either[E, A]): Validation[E, A]
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
weakHashMapMemo[K, V]: Memo[K, V]
-
def
withResource[T, R](value: ⇒ T, evaluate: (T) ⇒ R, whenComputing: (Throwable) ⇒ R, whenClosing: (Throwable) ⇒ Unit)(implicit r: Resource[T]): R
-
implicit
def
wrapRope[A](rope: Rope[A])(implicit arg0: ClassManifest[A]): WrappedRope[A]
-
implicit
def
wrapRopeChar(rope: Rope[Char]): RopeCharW
-
def
writer[W, A](w: W, a: A): Writer[W, A]
-
def
writerT[M[_], W, A](v: M[(W, A)]): WriterT[M, W, A]
-
def
zero[Z](z: Z): Zero[Z]
-
def
zip[A](s: Stream[A]): ZipStream[A]
-
def
zipper[A](ls: Stream[A], a: A, rs: Stream[A]): Zipper[A]
-
def
×[A, B]: (A) ⇒ (B) ⇒ (A, B)
-
lazy val
π: Double
-
lazy val
π2: Double
-
def
∅[Z]: Z
-
def
⊥: Nothing
-
def
★[W[_], A, B](f: (W[A]) ⇒ B): Cokleisli[W, A, B]
-
def
☆[M[_], A, B](f: (A) ⇒ M[B]): Kleisli[M, A, B]
Inherited from AnyRef
Inherited from Any