Type Members
-
type
->
[A, B]
= ~>[[B]A, [B]B]
-
type
:&:
[A, B]
= LazyTuple2[A, B]
-
type
ArraySeq
[A]
= ArraySeq[A]
-
type
Id
[A]
= A
-
trait
IndSeq
[A]
extends NewType[FingerTree[Int, A]]
-
trait
Konst
[A]
extends AnyRef
-
-
class
Rope
[A]
extends NewType[FingerTreeIntPlus[ImmutableArray[A]]]
-
class
RopeBuilder
[A]
extends Builder[A, Rope[A]]
-
class
RopeCharW
extends PimpedType[Rope[Char]]
-
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
Tuple2W
[A, B]
extends PimpedType[(A, B)]
-
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)]
-
-
class
WrappedRope
[A]
extends NewType[Rope[A]] with IndexedSeq[A] with IndexedSeqLike[A, WrappedRope[A]]
-
type
ℤ
= BigInt
-
type
⊤
= Any
-
type
⊥
= Nothing
Value Members
-
def
!=
(arg0: AnyRef): Boolean
-
def
!=
(arg0: Any): Boolean
-
def
##
(): Int
-
def
<∅>
[E[_], A]
(implicit e: Empty[E]): E[A]
-
def
==
(arg0: AnyRef): Boolean
-
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
: 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]
-
-
object
IndSeq
extends AnyRef
-
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]
-
object
Node
extends AnyRef
-
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]
-
object
Rope
extends AnyRef
-
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]
-
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]
-
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]]
-
def
getClass
(): java.lang.Class[_]
-
def
gets
[S, A]
(f: (S) ⇒ A): State[S, A]
-
def
hashCode
(): Int
-
def
id
: ~>[Id, Id]
-
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: Ordering[K]): Memo[K, V]
-
def
init
[S]
: State[S, S]
-
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): $colon$amp$colon[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]
-
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]
-
def
notify
(): Unit
-
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]
-
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]
-
def
wait
(): Unit
-
def
wait
(arg0: Long, arg1: Int): Unit
-
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
∅
[Z]
(implicit z: Zero[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
