dsl

Type Members

abstract type BuildKeyConstraint[K]

Definition Classes
MapSub
class ParsersW[P <: Parsers] extends AnyRef

Definition Classes
Parsers
abstract type XMap[K, V] <: Map[K, V] with MapLike[K, V, XMap[K, V]]

Definition Classes
MapSub

Abstract Value Members

abstract def ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

Attributes
protected
Definition Classes
MapSub
abstract def ab_-[K, V](m: XMap[K, V], k: K)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

Attributes
protected
Definition Classes
MapSub
implicit abstract def buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]

Attributes
protected
Definition Classes
MapSub

Concrete Value Members

val <:<: Category[<:<]

Definition Classes
TypeConstraintInstances
val =:=: Category[=:=]

Definition Classes
TypeConstraintInstances
val Accepted: Status.Accepted.type
val AlreadyReported: Status.AlreadyReported.type
val BadGateway: Status.BadGateway.type
val BadRequest: Status.BadRequest.type
implicit val BigDecimalMultiplicationNewType: Monoid[@@[BigDecimal, Multiplication]]

Definition Classes
BigDecimalInstances
val CONNECT: Method.CONNECT
implicit val CharacterSetOrder: Order[CharsetRange]

Definition Classes
CharsetRangeInstances
implicit val CharsetShow: Show[Charset]

Definition Classes
CharsetRangeInstances
val Conflict: Status.Conflict.type
val Continue: Status.Continue.type
val Created: Status.Created.type
val DELETE: Method.DELETE
val ExpectationFailed: Status.ExpectationFailed.type
val FailedDependency: Status.FailedDependency.type
implicit def FirstLeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]

Definition Classes
EitherInstances
implicit val FirstLeftProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

Definition Classes
EitherInstances
implicit def FirstRightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]

Definition Classes
EitherInstances
implicit val FirstRightProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

Definition Classes
EitherInstances
val Forbidden: Status.Forbidden.type
val Found: Status.Found.type
val GET: Method.GET
val GatewayTimeout: Status.GatewayTimeout.type
val Gone: Status.Gone.type
val HEAD: Method.HEAD
val HttpVersionNotSupported: Status.HttpVersionNotSupported.type
implicit val HttpVersionOrder: Order[HttpVersion]

Definition Classes
HttpVersionInstances
implicit val HttpVersionShow: Show[HttpVersion]

Definition Classes
HttpVersionInstances
val IMUsed: Status.IMUsed.type
val InsufficientStorage: Status.InsufficientStorage.type
val InternalServerError: Status.InternalServerError.type
implicit def LastLeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]

Definition Classes
EitherInstances
implicit val LastLeftProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

Definition Classes
EitherInstances
implicit def LastRightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]

Definition Classes
EitherInstances
implicit val LastRightProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

Definition Classes
EitherInstances
implicit def LeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]LeftProjection[E, α], [α]Either[E, α]]

Definition Classes
EitherInstances
implicit val LeftProjectionIso2: scalaz.Isomorphism.<~~>[LeftProjection, Either]

Definition Classes
EitherInstances
val LengthRequired: Status.LengthRequired.type
val Locked: Status.Locked.type
val LoopDetected: Status.LoopDetected.type
implicit val MethodInstances: Show[Method] with Equal[Method]

Definition Classes
MethodInstances
val MethodNotAllowed: Status.MethodNotAllowed.type
val MovedPermanently: Status.MovedPermanently.type
val MultiStatus: Status.MultiStatus.type
val MultipleChoices: Status.MultipleChoices.type
val NetworkAuthenticationRequired: Status.NetworkAuthenticationRequired.type
val NoContent: Status.NoContent.type
val NonAuthoritativeInformation: Status.NonAuthoritativeInformation.type
val NotAcceptable: Status.NotAcceptable.type
val NotExtended: Status.NotExtended.type
val NotFound: Status.NotFound.type
val NotImplemented: Status.NotImplemented.type
val NotModified: Status.NotModified.type
val OPTIONS: Method.OPTIONS
val Ok: Status.Ok.type
val PATCH: Method.PATCH
val POST: Method.POST
val PUT: Method.PUT
val PartialContent: Status.PartialContent.type
val PayloadTooLarge: Status.PayloadTooLarge.type
val PaymentRequired: Status.PaymentRequired.type
val PermanentRedirect: Status.PermanentRedirect.type
val PreconditionFailed: Status.PreconditionFailed.type
val PreconditionRequired: Status.PreconditionRequired.type
val Processing: Status.Processing.type
val ProxyAuthenticationRequired: Status.ProxyAuthenticationRequired.type
val RangeNotSatisfiable: Status.RangeNotSatisfiable.type
val RequestHeaderFieldsTooLarge: Status.RequestHeaderFieldsTooLarge.type
val RequestTimeout: Status.RequestTimeout.type
val ResetContent: Status.ResetContent.type
implicit def RightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]RightProjection[α, A], [α]Either[α, A]]

Definition Classes
EitherInstances
implicit val RightProjectionIso2: scalaz.Isomorphism.<~~>[RightProjection, Either]

Definition Classes
EitherInstances
val SeeOther: Status.SeeOther.type
val ServiceUnavailable: Status.ServiceUnavailable.type
implicit val StatusOrder: Order[Status]

Definition Classes
StatusInstances
implicit val StatusShow: Show[Status]

Definition Classes
StatusInstances
val SwitchingProtocols: Status.SwitchingProtocols.type
val TRACE: Method.TRACE
val TemporaryRedirect: Status.TemporaryRedirect.type
implicit def ToCaseInsensitiveStringSyntax(cs: CharSequence): CaseInsensitiveStringOps

Definition Classes
CaseInsensitiveStringSyntax
val TooManyRequests: Status.TooManyRequests.type
val Unauthorized: Status.Unauthorized.type
val UnprocessableEntity: Status.UnprocessableEntity.type
val UnsupportedMediaType: Status.UnsupportedMediaType.type
val UpgradeRequired: Status.UpgradeRequired.type
val UriTooLong: Status.UriTooLong.type
val UseProxy: Status.UseProxy.type
val VariantAlsoNegotiates: Status.VariantAlsoNegotiates.type
final def alter[K, A](m: scalaz.std.MapSubFunctions.XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, A]

Definition Classes
MapSubFunctions
implicit val bigDecimalInstance: Monoid[BigDecimal] with Enum[BigDecimal] with Show[BigDecimal]

Definition Classes
BigDecimalInstances
implicit val bigIntInstance: Monoid[BigInt] with Enum[BigInt] with Show[BigInt]

Definition Classes
BigInts
implicit val bigIntMultiplication: Monoid[@@[BigInt, Multiplication]] with Order[@@[BigInt, Multiplication]] with Show[@@[BigInt, Multiplication]]

Definition Classes
BigInts
implicit val bigIntegerInstance: Monoid[BigInteger] with Enum[BigInteger] with Show[BigInteger]

Definition Classes
BigIntegerInstances
implicit val bigIntegerMultiplication: Monoid[@@[BigInteger, Multiplication]] with Order[@@[BigInteger, Multiplication]] with Show[@@[BigInteger, Multiplication]]

Definition Classes
BigIntegerInstances
def binFile(file: File): EntityDecoder[File]

Definition Classes
EntityDecoderInstances
implicit val binary: EntityDecoder[ByteVector]

Definition Classes
EntityDecoderInstances
implicit val booleanConjunctionNewTypeInstance: Monoid[@@[Boolean, Conjunction]] with Enum[@@[Boolean, Conjunction]]

Definition Classes
AnyValInstances
implicit val booleanDisjunctionNewTypeInstance: Monoid[@@[Boolean, Disjunction]] with Enum[@@[Boolean, Disjunction]]

Definition Classes
AnyValInstances
implicit object booleanInstance extends Enum[Boolean] with Show[Boolean]

Definition Classes
AnyValInstances
implicit val byteArrayEncoder: EntityEncoder[Array[Byte]]

Definition Classes
EntityEncoderInstances
implicit val byteBufferEncoder: EntityEncoder[ByteBuffer]

Definition Classes
EntityEncoderInstances
implicit val byteEncoder: EntityEncoder[Byte]

Definition Classes
EntityEncoderInstances
implicit val byteInstance: Monoid[Byte] with Enum[Byte] with Show[Byte]

Definition Classes
AnyValInstances
implicit val byteMultiplicationNewType: Monoid[@@[Byte, Multiplication]] with Enum[@@[Byte, Multiplication]]

Definition Classes
AnyValInstances
implicit val byteVectorEncoder: EntityEncoder[ByteVector]

Definition Classes
EntityEncoderInstances
implicit val callableMonad: Monad[Callable]

Definition Classes
CallableInstances
implicit def callableOrder[A](implicit arg0: Order[A]): Order[Callable[A]]

Definition Classes
CallableInstances
implicit val char: Monoid[Char] with Enum[Char] with Show[Char]

Definition Classes
AnyValInstances
implicit def charArrayEncoder(implicit charset: Charset): EntityEncoder[Array[Char]]

Definition Classes
EntityEncoderInstances
implicit val charEncoder: EntityEncoder[Char]

Definition Classes
EntityEncoderInstances
implicit val charMultiplicationNewType: Monoid[@@[Char, Multiplication]] with Enum[@@[Char, Multiplication]]

Definition Classes
AnyValInstances
implicit def charSequenceEncoder[A <: CharSequence](implicit charset: Charset): EntityEncoder[CharSequence]

Definition Classes
EntityEncoderInstances
def chunkedEncoder[A](f: (A) ⇒ Channel[Task, Int, ByteVector], chunkSize: Int): EntityEncoder[A]

Definition Classes
EntityEncoderInstances
implicit val doubleInstance: Order[Double] with Show[Double]

Definition Classes
AnyValInstances
implicit def eitherEqual[A, B](implicit A0: Equal[A], B0: Equal[B]): Equal[Either[A, B]]

Definition Classes
EitherInstances0
implicit def eitherFirstLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], First]]

Definition Classes
EitherInstances0
implicit val eitherFirstLeftInstance: IsomorphismBifunctor[[a, b]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

Definition Classes
EitherInstances
implicit def eitherFirstLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], First]]

Definition Classes
EitherInstances
implicit def eitherFirstLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], First]]

Definition Classes
EitherInstances
implicit def eitherFirstLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]

Definition Classes
EitherInstances
implicit def eitherFirstLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], First]]

Definition Classes
EitherInstances0
implicit def eitherFirstRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], First]]

Definition Classes
EitherInstances0
implicit def eitherFirstRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]

Definition Classes
EitherInstances
implicit def eitherFirstRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], First]]

Definition Classes
EitherInstances
implicit def eitherFirstRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], First]]

Definition Classes
EitherInstances
implicit def eitherFirstRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], First]]

Definition Classes
EitherInstances0
implicit val eitherInstance: Bitraverse[Either]

Definition Classes
EitherInstances
implicit def eitherLastLeftEqual[A, X](implicit A0: Equal[A]): Equal[@@[LeftProjection[A, X], Last]]

Definition Classes
EitherInstances0
implicit def eitherLastLeftMonoid[A, X](implicit MonoidX: Monoid[X]): Monoid[@@[LeftProjection[A, X], Last]]

Definition Classes
EitherInstances
implicit def eitherLastLeftOrder[A, X](implicit OrderA: Order[A]): Order[@@[LeftProjection[A, X], Last]]

Definition Classes
EitherInstances
implicit def eitherLastLeftRInstance[R]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]

Definition Classes
EitherInstances
implicit def eitherLastLeftSemigroup[A, X](implicit arg0: Semigroup[A]): Semigroup[@@[LeftProjection[A, X], Last]]

Definition Classes
EitherInstances0
implicit def eitherLastRightEqual[X, A](implicit A0: Equal[A]): Equal[@@[RightProjection[X, A], Last]]

Definition Classes
EitherInstances0
implicit def eitherLastRightLInstance[L]: Monad[[α]AnyRef { ... /* 2 definitions in type refinement */ }]

Definition Classes
EitherInstances
implicit def eitherLastRightMonoid[X, A](implicit MonoidX: Monoid[X]): Monoid[@@[RightProjection[X, A], Last]]

Definition Classes
EitherInstances
implicit def eitherLastRightOrder[X, A](implicit OrderA: Order[A]): Order[@@[RightProjection[X, A], Last]]

Definition Classes
EitherInstances
implicit def eitherLastRightSemigroup[X, A](implicit arg0: Semigroup[A]): Semigroup[@@[RightProjection[X, A], Last]]

Definition Classes
EitherInstances0
implicit def eitherLeftEqual[A, X](implicit A0: Equal[A]): Equal[LeftProjection[A, X]]

Definition Classes
EitherInstances0
implicit val eitherLeftInstance: IsomorphismBifunctor[LeftProjection, Either]

Definition Classes
EitherInstances
implicit def eitherLeftMonoid[A, X](implicit MonoidA: Monoid[A], MonoidX: Monoid[X]): Monoid[LeftProjection[A, X]]

Definition Classes
EitherInstances
implicit def eitherLeftOrder[A, X](implicit OrderA: Order[A]): Order[LeftProjection[A, X]]

Definition Classes
EitherInstances
implicit def eitherLeftRInstance[R]: Monad[[α]LeftProjection[α, R]] { def point[A](a: => A): scala.util.Either.LeftProjection[A,Nothing] }

Definition Classes
EitherInstances
implicit def eitherLeftSemigroup[A, X](implicit SemigroupA: Semigroup[A], MonoidX: Monoid[X]): Semigroup[LeftProjection[A, X]]

Definition Classes
EitherInstances0
implicit def eitherMonad[L]: Traverse[[a]Either[L, a]] with Monad[[a]Either[L, a]] with Cozip[[a]Either[L, a]] { def point[A](a: => A): scala.util.Right[Nothing,A] }

Definition Classes
EitherInstances
implicit def eitherOrder[A, B](implicit OrderA: Order[A], OrderB: Order[B]): Order[Either[A, B]]

Definition Classes
EitherInstances
implicit def eitherRightEqual[X, A](implicit A0: Equal[A]): Equal[RightProjection[X, A]]

Definition Classes
EitherInstances0
implicit val eitherRightInstance: IsomorphismBifunctor[RightProjection, Either]

Definition Classes
EitherInstances
implicit def eitherRightLInstance[L]: Monad[[α]RightProjection[L, α]] { def point[A](a: => A): scala.util.Either.RightProjection[Nothing,A] }

Definition Classes
EitherInstances
implicit def eitherRightMonoid[X, A](implicit MonoidX: Monoid[X], MonoidA: Monoid[A]): Monoid[RightProjection[X, A]]

Definition Classes
EitherInstances
implicit def eitherRightOrder[X, A](implicit OrderA: Order[A]): Order[RightProjection[X, A]]

Definition Classes
EitherInstances
implicit def eitherRightSemigroup[X, A](implicit MonoidX: Monoid[X], SemigroupA: Semigroup[A]): Semigroup[RightProjection[X, A]]

Definition Classes
EitherInstances0
implicit val entityEncoderContravariant: Contravariant[EntityEncoder]

Definition Classes
EntityEncoderInstances
implicit def enumInstance[E <: Enum[E]]: Equal[E]

Definition Classes
EnumInstances
def error[T](t: Throwable): EntityDecoder[T]

Definition Classes
EntityDecoderInstances
implicit val fileEncoder: EntityEncoder[File]

Definition Classes
EntityEncoderInstances
implicit val filePathEncoder: EntityEncoder[java.nio.file.Path]

Definition Classes
EntityEncoderInstances
implicit val floatInstance: Order[Float] with Show[Float]

Definition Classes
AnyValInstances
implicit def function0Equal[R](implicit arg0: Equal[R]): Equal[() ⇒ R]

Definition Classes
FunctionInstances
implicit val function0Instance: Traverse[Function0] with Monad[Function0] with Comonad[Function0] with Distributive[Function0]

Definition Classes
FunctionInstances
implicit def function1Cobind[A, R](implicit A0: Semigroup[A]): Cobind[[α](A) ⇒ α]

Definition Classes
FunctionInstances1
implicit def function1Comonad[A, R](implicit A0: Monoid[A]): Comonad[[α](A) ⇒ α]

Definition Classes
FunctionInstances0
implicit def function1Contravariant[R]: Contravariant[[a](a) ⇒ R]

Definition Classes
FunctionInstances
implicit def function1Covariant[T]: Monad[[a](T) ⇒ a] with Zip[[a](T) ⇒ a] with Unzip[[a](T) ⇒ a] with Distributive[[a](T) ⇒ a]

Definition Classes
FunctionInstances
implicit def function1CovariantByName[T]: Monad[[a](⇒ T) ⇒ a] with Zip[[a](⇒ T) ⇒ a] with Unzip[[a](⇒ T) ⇒ a] with Distributive[[a](⇒ T) ⇒ a]

Definition Classes
FunctionInstances0
implicit val function1Instance: Arrow[Function1] with Category[Function1] with Choice[Function1]

Definition Classes
FunctionInstances
implicit def function1Monoid[A, R](implicit R0: Monoid[R]): Monoid[(A) ⇒ R]

Definition Classes
FunctionInstances0
implicit def function1Semigroup[A, R](implicit R0: Semigroup[R]): Semigroup[(A) ⇒ R]

Definition Classes
FunctionInstances1
implicit def function2Instance[T1, T2]: Monad[[a](T1, T2) ⇒ a]

Definition Classes
FunctionInstances
implicit def function3Instance[T1, T2, T3]: Monad[[a](T1, T2, T3) ⇒ a]

Definition Classes
FunctionInstances
implicit def function4Instance[T1, T2, T3, T4]: Monad[[a](T1, T2, T3, T4) ⇒ a]

Definition Classes
FunctionInstances
implicit def function5Instance[T1, T2, T3, T4, T5]: Monad[[a](T1, T2, T3, T4, T5) ⇒ a]

Definition Classes
FunctionInstances
implicit def function6Instance[T1, T2, T3, T4, T5, T6]: Monad[[a](T1, T2, T3, T4, T5, T6) ⇒ a]

Definition Classes
FunctionInstances
implicit def function7Instance[T1, T2, T3, T4, T5, T6, T7]: Monad[[a](T1, T2, T3, T4, T5, T6, T7) ⇒ a]

Definition Classes
FunctionInstances
implicit def function8Instance[T1, T2, T3, T4, T5, T6, T7, T8]: Monad[[a](T1, T2, T3, T4, T5, T6, T7, T8) ⇒ a]

Definition Classes
FunctionInstances
def futureComonad(duration: Duration)(implicit executionContext: ExecutionContext): Comonad[Future]

Definition Classes
FutureInstances
implicit def futureEncoder[A](implicit W: EntityEncoder[A], ec: ExecutionContext): EntityEncoder[Future[A]]

Definition Classes
EntityEncoderInstances0
implicit def futureInstance(implicit ec: ExecutionContext): Monad[Future] with Cobind[Future]

Definition Classes
FutureInstances1
implicit def futureMonoid[A](implicit g: Monoid[A], ec: ExecutionContext): Monoid[Future[A]]

Definition Classes
FutureInstances
implicit def futureSemigroup[A](implicit m: Semigroup[A], ec: ExecutionContext): Semigroup[Future[A]]

Definition Classes
FutureInstances1
object generic extends IndexedSeqSubVector with IndexedSeqSubInstances

Definition Classes
VectorInstances
final def getOrAdd[F[_], K, A](m: scalaz.std.MapSubFunctions.XMap[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F], K: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): F[(scalaz.std.MapSubFunctions.XMap[K, A], A)]

Definition Classes
MapSubFunctions
implicit def inputStreamEncoder[A <: InputStream]: EntityEncoder[A]

Definition Classes
EntityEncoderInstances
final def insertWith[K, A](m1: scalaz.std.MapSubFunctions.XMap[K, A], k: K, v: A)(f: (A, A) ⇒ A)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, A]

Definition Classes
MapSubFunctions
implicit val intInstance: Monoid[Int] with Enum[Int] with Show[Int]

Definition Classes
AnyValInstances
implicit val intMultiplicationNewType: Monoid[@@[Int, Multiplication]] with Enum[@@[Int, Multiplication]]

Definition Classes
AnyValInstances
final def intersectWith[K, A, B, C](m1: scalaz.std.MapSubFunctions.XMap[K, A], m2: scalaz.std.MapSubFunctions.XMap[K, B])(f: (A, B) ⇒ C)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, C]

Definition Classes
MapSubFunctions
final def intersectWithKey[K, A, B, C](m1: scalaz.std.MapSubFunctions.XMap[K, A], m2: scalaz.std.MapSubFunctions.XMap[K, B])(f: (K, A, B) ⇒ C)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, C]

Definition Classes
MapSubFunctions
implicit def listEqual[A](implicit A0: Equal[A]): Equal[List[A]]

Definition Classes
ListInstances0
implicit val listInstance: Traverse[List] with MonadPlus[List] with Each[List] with Index[List] with Length[List] with Zip[List] with Unzip[List] with Align[List] with IsEmpty[List] with Cobind[List] { def empty[A]: scala.collection.immutable.Nil.type }

Definition Classes
ListInstances
implicit def listMonoid[A]: Monoid[List[A]]

Definition Classes
ListInstances
implicit def listOrder[A](implicit A0: Order[A]): Order[List[A]]

Definition Classes
ListInstances
implicit def listShow[A](implicit arg0: Show[A]): Show[List[A]]

Definition Classes
ListInstances
implicit val longInstance: Monoid[Long] with Enum[Long] with Show[Long]

Definition Classes
AnyValInstances
implicit val longMultiplicationNewType: Monoid[@@[Long, Multiplication]] with Enum[@@[Long, Multiplication]]

Definition Classes
AnyValInstances
implicit val mapEntryBitraverse: Bitraverse[Entry]

Definition Classes
MapInstances
implicit def mapEqual[K, V](implicit arg0: Order[K], arg1: Equal[V]): Equal[scalaz.std.MapSubInstances0.XMap[K, V]]

Definition Classes
MapSubInstances0
implicit def mapFoldable[K]: Foldable[[V]scalaz.std.MapSubInstances0.XMap[K, V]]

Definition Classes
MapSubInstances0
implicit def mapInstance[K](implicit arg0: scalaz.std.MapSubInstances.BuildKeyConstraint[K]): Traverse[[V]scalaz.std.MapSubInstances.XMap[K, V]] with IsEmpty[[V]scalaz.std.MapSubInstances.XMap[K, V]] with Bind[[V]scalaz.std.MapSubInstances.XMap[K, V]] with Align[[V]scalaz.std.MapSubInstances.XMap[K, V]]

Definition Classes
MapSubInstances
final def mapKeys[K, K2, A](m: scalaz.std.MapSubFunctions.XMap[K, A])(f: (K) ⇒ K2)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K2]): scalaz.std.MapSubFunctions.XMap[K2, A]

Definition Classes
MapSubFunctions
implicit def mapMonoid[K, V](implicit arg0: scalaz.std.MapSubInstances.BuildKeyConstraint[K], arg1: Semigroup[V]): Monoid[scalaz.std.MapSubInstances.XMap[K, V]]

Definition Classes
MapSubInstances
implicit def mapOrder[K, V](implicit arg0: Order[K], arg1: Order[V]): Order[scalaz.std.MapSubInstances.XMap[K, V]]

Definition Classes
MapSubInstances
implicit def mapShow[K, V](implicit K: Show[K], V: Show[V]): Show[scalaz.std.MapSubInstances.XMap[K, V]]

Definition Classes
MapSubInstances
implicit def naturalTransformationEncoder[F[_], A](implicit N: ~>[F, Task], W: EntityEncoder[A]): EntityEncoder[F[A]]

Definition Classes
EntityEncoderInstances0
implicit val nodeSeqInstance: Monoid[NodeSeq] with Show[NodeSeq] with Equal[NodeSeq]

Definition Classes
NodeSeqInstances
implicit def optionEqual[A](implicit A0: Equal[A]): Equal[Option[A]]

Definition Classes
OptionInstances0
implicit def optionFirst[A]: Monoid[FirstOption[A]]

Definition Classes
OptionInstances
implicit def optionFirstMonad: Monad[FirstOption]

Definition Classes
OptionInstances
implicit def optionFirstOrder[A](implicit arg0: Order[A]): Order[FirstOption[A]]

Definition Classes
OptionInstances
implicit def optionFirstShow[A](implicit arg0: Show[A]): Show[FirstOption[A]]

Definition Classes
OptionInstances
implicit val optionInstance: Traverse[Option] with MonadPlus[Option] with Each[Option] with Index[Option] with Length[Option] with Cozip[Option] with Zip[Option] with Unzip[Option] with Align[Option] with IsEmpty[Option] with Cobind[Option] with Optional[Option] { ... /* 2 definitions in type refinement */ }

Definition Classes
OptionInstances
implicit def optionLast[A]: Monoid[LastOption[A]]

Definition Classes
OptionInstances
implicit def optionLastMonad: Monad[LastOption]

Definition Classes
OptionInstances
implicit def optionLastOrder[A](implicit arg0: Order[A]): Order[LastOption[A]]

Definition Classes
OptionInstances
implicit def optionLastShow[A](implicit arg0: Show[A]): Show[LastOption[A]]

Definition Classes
OptionInstances
implicit def optionMax[A](implicit o: Order[A]): Monoid[MaxOption[A]]

Definition Classes
OptionInstances
implicit def optionMaxMonad: Monad[MaxOption]

Definition Classes
OptionInstances
implicit def optionMaxOrder[A](implicit arg0: Order[A]): Order[MaxOption[A]]

Definition Classes
OptionInstances
implicit def optionMaxShow[A](implicit arg0: Show[A]): Show[MaxOption[A]]

Definition Classes
OptionInstances
implicit def optionMin[A](implicit o: Order[A]): Monoid[MinOption[A]]

Definition Classes
OptionInstances
implicit def optionMinMonad: Monad[MinOption]

Definition Classes
OptionInstances
implicit def optionMinOrder[A](implicit arg0: Order[A]): Order[MinOption[A]]

Definition Classes
OptionInstances
implicit def optionMinShow[A](implicit arg0: Show[A]): Show[MinOption[A]]

Definition Classes
OptionInstances
implicit def optionMonoid[A](implicit arg0: Semigroup[A]): Monoid[Option[A]]

Definition Classes
OptionInstances
implicit def optionOrder[A](implicit A0: Order[A]): Order[Option[A]]

Definition Classes
OptionInstances
implicit def optionShow[A](implicit arg0: Show[A]): Show[Option[A]]

Definition Classes
OptionInstances
def orderingMonoid[A]: Monoid[Ordering[A]]

Definition Classes
OrderingInstances
def parserMonad[P <: Parsers](p: P): Monad[[A]scalaz.std.util.parsing.combinator.Parsers.parserMonad.P.Parser[A]] forSome {val _1995: ParsersW[P]}

Definition Classes
Parsers
implicit val partialFunctionInstance: Arrow[PartialFunction] with Category[PartialFunction] with Choice[PartialFunction]

Definition Classes
PartialFunctionInstances
implicit def process0Encoder[A](implicit W: EntityEncoder[A]): EntityEncoder[Process0[A]]

Definition Classes
EntityEncoderInstances0
macro def q(d: Double): QValue

Definition Classes
QValueFunctions
implicit val qValueOrder: Order[QValue]

Definition Classes
QValueInstances
implicit val qValueShow: Show[QValue]

Definition Classes
QValueInstances
implicit def readerEncoder[A <: Reader](implicit charset: Charset): EntityEncoder[A]

Definition Classes
EntityEncoderInstances
implicit def requestSyntax(req: Task[Request]): TaskMessageOps[Request]

Definition Classes
MessageSyntax
def resolve(base: Uri, reference: Uri): Uri

Definition Classes
UriFunctions
implicit def responseSyntax(resp: Task[Response]): TaskResponseOps

Definition Classes
MessageSyntax
implicit val setInstance: Foldable[Set] with IsEmpty[Set] with Length[Set]

Definition Classes
SetInstances
implicit def setMonoid[A]: Monoid[Set[A]]

Definition Classes
SetInstances
implicit def setOrder[A](implicit arg0: Order[A]): Order[Set[A]]

Definition Classes
SetInstances
implicit def setShow[A](implicit arg0: Show[A]): Show[Set[A]]

Definition Classes
SetInstances
implicit val shortInstance: Monoid[Short] with Enum[Short] with Show[Short]

Definition Classes
AnyValInstances
implicit val shortMultiplicationNewType: Monoid[@@[Short, Multiplication]] with Enum[@@[Short, Multiplication]]

Definition Classes
AnyValInstances
def showEncoder[A](implicit charset: Charset, show: Show[A]): EntityEncoder[A]

Definition Classes
EntityEncoderInstances0
implicit def sourceEncoder[A](implicit W: EntityEncoder[A]): EntityEncoder[Process[Task, A]]

Definition Classes
EntityEncoderInstances0
implicit def streamEqual[A](implicit A0: Equal[A]): Equal[Stream[A]]

Definition Classes
StreamInstances
implicit val streamInstance: Traverse[Stream] with MonadPlus[Stream] with Each[Stream] with Index[Stream] with Length[Stream] with Zip[Stream] with Unzip[Stream] with Align[Stream] with IsEmpty[Stream] with Cobind[Stream]

Definition Classes
StreamInstances
implicit def streamMonoid[A]: Monoid[Stream[A]]

Definition Classes
StreamInstances
implicit def streamShow[A](implicit A0: Show[A]): Show[Stream[A]]

Definition Classes
StreamInstances
implicit val streamZipApplicative: Applicative[[α]AnyRef { ... /* 2 definitions in type refinement */ }]

Definition Classes
StreamInstances
implicit def stringEncoder(implicit charset: Charset): EntityEncoder[String]

Definition Classes
EntityEncoderInstances
implicit object stringInstance extends Monoid[String] with Show[String] with Equal[String] with Order[String] with IsEmpty[[α]String]

Definition Classes
StringInstances
implicit def taskEncoder[A](implicit W: EntityEncoder[A]): EntityEncoder[Task[A]]

Definition Classes
EntityEncoderInstances
implicit val text: EntityDecoder[String]

Definition Classes
EntityDecoderInstances
def textFile(file: File): EntityDecoder[File]

Definition Classes
EntityDecoderInstances
implicit val tuple1Cozip: Cozip[Tuple1]

Definition Classes
TupleInstances1
implicit def tuple1Equal[A1](implicit A1: Equal[A1]): Equal[(A1)]

Definition Classes
TupleInstances0
implicit val tuple1Instance: Traverse[Tuple1] with Monad[Tuple1] with Comonad[Tuple1]

Definition Classes
TupleInstances0
implicit def tuple1Monoid[A1](implicit A1: Monoid[A1]): Monoid[(A1)]

Definition Classes
TupleInstances1
implicit def tuple1Order[A1](implicit A1: Order[A1]): Order[(A1)]

Definition Classes
TupleInstances1
implicit def tuple1Semigroup[A1](implicit A1: Semigroup[A1]): Semigroup[(A1)]

Definition Classes
TupleInstances0
implicit def tuple1Show[A1](implicit A1: Show[A1]): Show[(A1)]

Definition Classes
TupleInstances1
implicit val tuple2Bitraverse: Bitraverse[Tuple2]

Definition Classes
TupleInstances0
implicit def tuple2Cozip[A1]: Cozip[[x](A1, x)]

Definition Classes
TupleInstances1
implicit def tuple2Equal[A1, A2](implicit A1: Equal[A1], A2: Equal[A2]): Equal[(A1, A2)]

Definition Classes
TupleInstances0
implicit def tuple2Instance[A1]: Traverse[[x](A1, x)] with Comonad[[x](A1, x)]

Definition Classes
TupleInstances0
implicit def tuple2Monad[A1](implicit A1: Monoid[A1]): Monad[[x](A1, x)]

Definition Classes
TupleInstances1
implicit def tuple2Monoid[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monoid[(A1, A2)]

Definition Classes
TupleInstances1
implicit def tuple2Order[A1, A2](implicit A1: Order[A1], A2: Order[A2]): Order[(A1, A2)]

Definition Classes
TupleInstances1
implicit def tuple2Semigroup[A1, A2](implicit A1: Semigroup[A1], A2: Semigroup[A2]): Semigroup[(A1, A2)]

Definition Classes
TupleInstances0
implicit def tuple2Show[A1, A2](implicit A1: Show[A1], A2: Show[A2]): Show[(A1, A2)]

Definition Classes
TupleInstances1
implicit def tuple3Cozip[A1, A2]: Cozip[[x](A1, A2, x)]

Definition Classes
TupleInstances1
implicit def tuple3Equal[A1, A2, A3](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3]): Equal[(A1, A2, A3)]

Definition Classes
TupleInstances0
implicit def tuple3Functor[A1, A2]: Traverse[[x](A1, A2, x)]

Definition Classes
TupleInstances0
implicit def tuple3Monad[A1, A2](implicit A1: Monoid[A1], A2: Monoid[A2]): Monad[[x](A1, A2, x)]

Definition Classes
TupleInstances1
implicit def tuple3Monoid[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monoid[(A1, A2, A3)]

Definition Classes
TupleInstances1
implicit def tuple3Order[A1, A2, A3](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3]): Order[(A1, A2, A3)]

Definition Classes
TupleInstances1
implicit def tuple3Semigroup[A1, A2, A3](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3]): Semigroup[(A1, A2, A3)]

Definition Classes
TupleInstances0
implicit def tuple3Show[A1, A2, A3](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3]): Show[(A1, A2, A3)]

Definition Classes
TupleInstances1
implicit def tuple4Cozip[A1, A2, A3]: Cozip[[x](A1, A2, A3, x)]

Definition Classes
TupleInstances1
implicit def tuple4Equal[A1, A2, A3, A4](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4]): Equal[(A1, A2, A3, A4)]

Definition Classes
TupleInstances0
implicit def tuple4Functor[A1, A2, A3]: Traverse[[x](A1, A2, A3, x)]

Definition Classes
TupleInstances0
implicit def tuple4Monad[A1, A2, A3](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3]): Monad[[x](A1, A2, A3, x)]

Definition Classes
TupleInstances1
implicit def tuple4Monoid[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monoid[(A1, A2, A3, A4)]

Definition Classes
TupleInstances1
implicit def tuple4Order[A1, A2, A3, A4](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4]): Order[(A1, A2, A3, A4)]

Definition Classes
TupleInstances1
implicit def tuple4Semigroup[A1, A2, A3, A4](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4]): Semigroup[(A1, A2, A3, A4)]

Definition Classes
TupleInstances0
implicit def tuple4Show[A1, A2, A3, A4](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4]): Show[(A1, A2, A3, A4)]

Definition Classes
TupleInstances1
implicit def tuple5Cozip[A1, A2, A3, A4]: Cozip[[x](A1, A2, A3, A4, x)]

Definition Classes
TupleInstances1
implicit def tuple5Equal[A1, A2, A3, A4, A5](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5]): Equal[(A1, A2, A3, A4, A5)]

Definition Classes
TupleInstances0
implicit def tuple5Functor[A1, A2, A3, A4]: Traverse[[x](A1, A2, A3, A4, x)]

Definition Classes
TupleInstances0
implicit def tuple5Monad[A1, A2, A3, A4](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4]): Monad[[x](A1, A2, A3, A4, x)]

Definition Classes
TupleInstances1
implicit def tuple5Monoid[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monoid[(A1, A2, A3, A4, A5)]

Definition Classes
TupleInstances1
implicit def tuple5Order[A1, A2, A3, A4, A5](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5]): Order[(A1, A2, A3, A4, A5)]

Definition Classes
TupleInstances1
implicit def tuple5Semigroup[A1, A2, A3, A4, A5](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5]): Semigroup[(A1, A2, A3, A4, A5)]

Definition Classes
TupleInstances0
implicit def tuple5Show[A1, A2, A3, A4, A5](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5]): Show[(A1, A2, A3, A4, A5)]

Definition Classes
TupleInstances1
implicit def tuple6Cozip[A1, A2, A3, A4, A5]: Cozip[[x](A1, A2, A3, A4, A5, x)]

Definition Classes
TupleInstances1
implicit def tuple6Equal[A1, A2, A3, A4, A5, A6](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6]): Equal[(A1, A2, A3, A4, A5, A6)]

Definition Classes
TupleInstances0
implicit def tuple6Functor[A1, A2, A3, A4, A5]: Traverse[[x](A1, A2, A3, A4, A5, x)]

Definition Classes
TupleInstances0
implicit def tuple6Monad[A1, A2, A3, A4, A5](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5]): Monad[[x](A1, A2, A3, A4, A5, x)]

Definition Classes
TupleInstances1
implicit def tuple6Monoid[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monoid[(A1, A2, A3, A4, A5, A6)]

Definition Classes
TupleInstances1
implicit def tuple6Order[A1, A2, A3, A4, A5, A6](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6]): Order[(A1, A2, A3, A4, A5, A6)]

Definition Classes
TupleInstances1
implicit def tuple6Semigroup[A1, A2, A3, A4, A5, A6](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6]): Semigroup[(A1, A2, A3, A4, A5, A6)]

Definition Classes
TupleInstances0
implicit def tuple6Show[A1, A2, A3, A4, A5, A6](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6]): Show[(A1, A2, A3, A4, A5, A6)]

Definition Classes
TupleInstances1
implicit def tuple7Cozip[A1, A2, A3, A4, A5, A6]: Cozip[[x](A1, A2, A3, A4, A5, A6, x)]

Definition Classes
TupleInstances1
implicit def tuple7Equal[A1, A2, A3, A4, A5, A6, A7](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7]): Equal[(A1, A2, A3, A4, A5, A6, A7)]

Definition Classes
TupleInstances0
implicit def tuple7Functor[A1, A2, A3, A4, A5, A6]: Traverse[[x](A1, A2, A3, A4, A5, A6, x)]

Definition Classes
TupleInstances0
implicit def tuple7Monad[A1, A2, A3, A4, A5, A6](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6]): Monad[[x](A1, A2, A3, A4, A5, A6, x)]

Definition Classes
TupleInstances1
implicit def tuple7Monoid[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monoid[(A1, A2, A3, A4, A5, A6, A7)]

Definition Classes
TupleInstances1
implicit def tuple7Order[A1, A2, A3, A4, A5, A6, A7](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7]): Order[(A1, A2, A3, A4, A5, A6, A7)]

Definition Classes
TupleInstances1
implicit def tuple7Semigroup[A1, A2, A3, A4, A5, A6, A7](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7]): Semigroup[(A1, A2, A3, A4, A5, A6, A7)]

Definition Classes
TupleInstances0
implicit def tuple7Show[A1, A2, A3, A4, A5, A6, A7](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7]): Show[(A1, A2, A3, A4, A5, A6, A7)]

Definition Classes
TupleInstances1
implicit def tuple8Cozip[A1, A2, A3, A4, A5, A6, A7]: Cozip[[x](A1, A2, A3, A4, A5, A6, A7, x)]

Definition Classes
TupleInstances1
implicit def tuple8Equal[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Equal[A1], A2: Equal[A2], A3: Equal[A3], A4: Equal[A4], A5: Equal[A5], A6: Equal[A6], A7: Equal[A7], A8: Equal[A8]): Equal[(A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes
TupleInstances0
implicit def tuple8Functor[A1, A2, A3, A4, A5, A6, A7]: Traverse[[x](A1, A2, A3, A4, A5, A6, A7, x)]

Definition Classes
TupleInstances0
implicit def tuple8Monad[A1, A2, A3, A4, A5, A6, A7](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7]): Monad[[x](A1, A2, A3, A4, A5, A6, A7, x)]

Definition Classes
TupleInstances1
implicit def tuple8Monoid[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Monoid[A1], A2: Monoid[A2], A3: Monoid[A3], A4: Monoid[A4], A5: Monoid[A5], A6: Monoid[A6], A7: Monoid[A7], A8: Monoid[A8]): Monoid[(A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes
TupleInstances1
implicit def tuple8Order[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Order[A1], A2: Order[A2], A3: Order[A3], A4: Order[A4], A5: Order[A5], A6: Order[A6], A7: Order[A7], A8: Order[A8]): Order[(A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes
TupleInstances1
implicit def tuple8Semigroup[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Semigroup[A1], A2: Semigroup[A2], A3: Semigroup[A3], A4: Semigroup[A4], A5: Semigroup[A5], A6: Semigroup[A6], A7: Semigroup[A7], A8: Semigroup[A8]): Semigroup[(A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes
TupleInstances0
implicit def tuple8Show[A1, A2, A3, A4, A5, A6, A7, A8](implicit A1: Show[A1], A2: Show[A2], A3: Show[A3], A4: Show[A4], A5: Show[A5], A6: Show[A6], A7: Show[A7], A8: Show[A8]): Show[(A1, A2, A3, A4, A5, A6, A7, A8)]

Definition Classes
TupleInstances1
final def unionWith[K, A](m1: scalaz.std.MapSubFunctions.XMap[K, A], m2: scalaz.std.MapSubFunctions.XMap[K, A])(f: (A, A) ⇒ A)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, A]

Definition Classes
MapSubFunctions
final def unionWithKey[K, A](m1: scalaz.std.MapSubFunctions.XMap[K, A], m2: scalaz.std.MapSubFunctions.XMap[K, A])(f: (K, A, A) ⇒ A)(implicit arg0: scalaz.std.MapSubFunctions.BuildKeyConstraint[K]): scalaz.std.MapSubFunctions.XMap[K, A]

Definition Classes
MapSubFunctions
implicit val unitInstance: Monoid[Unit] with Enum[Unit] with Show[Unit]

Definition Classes
AnyValInstances
macro def uri(s: String): Uri

Definition Classes
UriFunctions
implicit def vectorEqual[A](implicit A0: Equal[A]): Equal[Vector[A]]

Definition Classes
VectorInstances0
implicit val vectorInstance: Traverse[scalaz.std.VectorInstances.generic.IxSq] with MonadPlus[scalaz.std.VectorInstances.generic.IxSq] with Each[scalaz.std.VectorInstances.generic.IxSq] with Index[scalaz.std.VectorInstances.generic.IxSq] with Length[scalaz.std.VectorInstances.generic.IxSq] with Zip[scalaz.std.VectorInstances.generic.IxSq] with Unzip[scalaz.std.VectorInstances.generic.IxSq] with IsEmpty[scalaz.std.VectorInstances.generic.IxSq] with Align[scalaz.std.VectorInstances.generic.IxSq] { def toIndexedSeq[A](fa: VectorInstances.this.generic.IxSq[A]): VectorInstances.this.generic.IxSq[A] }

Definition Classes
VectorInstances
implicit def vectorMonoid[A]: Monoid[Vector[A]]

Definition Classes
VectorInstances
implicit def vectorOrder[A](implicit A0: Order[A]): Order[Vector[A]]

Definition Classes
VectorInstances
implicit def vectorShow[A](implicit arg0: Show[A]): Show[Vector[A]]

Definition Classes
VectorInstances

Deprecated Value Members

implicit val intMetricSpace: MetricSpace[Int]

Definition Classes
AnyValInstances
Annotations
@deprecated
Deprecated
(Since version 7.0.1) MetricSpace is deprecated

package dsl

Type Members

abstract type BuildKeyConstraint[K]

class ParsersW[P <: Parsers] extends AnyRef

abstract type XMap[K, V] <: Map[K, V] with MapLike[K, V, XMap[K, V]]

Abstract Value Members

abstract def ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

abstract def ab_-[K, V](m: XMap[K, V], k: K)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

implicit abstract def buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]

Concrete Value Members

val <:<: Category[<:<]

val =:=: Category[=:=]

val Accepted: Status.Accepted.type

val AlreadyReported: Status.AlreadyReported.type

val BadGateway: Status.BadGateway.type

val BadRequest: Status.BadRequest.type

implicit val BigDecimalMultiplicationNewType: Monoid[@@[BigDecimal, Multiplication]]

val CONNECT: Method.CONNECT

implicit val CharacterSetOrder: Order[CharsetRange]

implicit val CharsetShow: Show[Charset]

val Conflict: Status.Conflict.type

val Continue: Status.Continue.type

val Created: Status.Created.type

val DELETE: Method.DELETE

val ExpectationFailed: Status.ExpectationFailed.type

val FailedDependency: Status.FailedDependency.type

implicit def FirstLeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]

implicit val FirstLeftProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

implicit def FirstRightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]

implicit val FirstRightProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

val Forbidden: Status.Forbidden.type

val Found: Status.Found.type

val GET: Method.GET

val GatewayTimeout: Status.GatewayTimeout.type

val Gone: Status.Gone.type

val HEAD: Method.HEAD

val HttpVersionNotSupported: Status.HttpVersionNotSupported.type

implicit val HttpVersionOrder: Order[HttpVersion]

implicit val HttpVersionShow: Show[HttpVersion]

val IMUsed: Status.IMUsed.type

val InsufficientStorage: Status.InsufficientStorage.type

val InternalServerError: Status.InternalServerError.type

implicit def LastLeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[E, α]]

implicit val LastLeftProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

implicit def LastRightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]AnyRef { ... /* 2 definitions in type refinement */ }, [α]Either[α, A]]

implicit val LastRightProjectionIso2: scalaz.Isomorphism.<~~>[[α, β]AnyRef { ... /* 2 definitions in type refinement */ }, Either]

implicit def LeftProjectionEIso2[E]: scalaz.Isomorphism.<~>[[α]LeftProjection[E, α], [α]Either[E, α]]

implicit val LeftProjectionIso2: scalaz.Isomorphism.<~~>[LeftProjection, Either]

val LengthRequired: Status.LengthRequired.type

val Locked: Status.Locked.type

val LoopDetected: Status.LoopDetected.type

implicit val MethodInstances: Show[Method] with Equal[Method]

val MethodNotAllowed: Status.MethodNotAllowed.type

val MovedPermanently: Status.MovedPermanently.type

val MultiStatus: Status.MultiStatus.type

val MultipleChoices: Status.MultipleChoices.type

val NetworkAuthenticationRequired: Status.NetworkAuthenticationRequired.type

val NoContent: Status.NoContent.type

val NonAuthoritativeInformation: Status.NonAuthoritativeInformation.type

val NotAcceptable: Status.NotAcceptable.type

val NotExtended: Status.NotExtended.type

val NotFound: Status.NotFound.type

val NotImplemented: Status.NotImplemented.type

val NotModified: Status.NotModified.type

val OPTIONS: Method.OPTIONS

val Ok: Status.Ok.type

val PATCH: Method.PATCH

val POST: Method.POST

val PUT: Method.PUT

val PartialContent: Status.PartialContent.type

val PayloadTooLarge: Status.PayloadTooLarge.type

val PaymentRequired: Status.PaymentRequired.type

val PermanentRedirect: Status.PermanentRedirect.type

val PreconditionFailed: Status.PreconditionFailed.type

val PreconditionRequired: Status.PreconditionRequired.type

val Processing: Status.Processing.type

val ProxyAuthenticationRequired: Status.ProxyAuthenticationRequired.type

val RangeNotSatisfiable: Status.RangeNotSatisfiable.type

val RequestHeaderFieldsTooLarge: Status.RequestHeaderFieldsTooLarge.type