Http4s

Type Members

type BuildKeyConstraint[K] = DummyImplicit

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

Definition Classes
Parsers
type XMap[K, V] = Map[K, V]

Definition Classes
MapSubMap → MapSub

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
val <:<: Category[<:<]

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

Definition Classes
TypeConstraintInstances
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit val BigDecimalMultiplicationNewType: Monoid[@@[BigDecimal, Multiplication]]

Definition Classes
BigDecimalInstances
implicit val CharacterSetOrder: Order[CharsetRange]

Definition Classes
CharsetRangeInstances
implicit val CharsetShow: Show[Charset]

Definition Classes
CharsetRangeInstances
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
implicit val HttpVersionOrder: Order[HttpVersion]

Definition Classes
HttpVersionInstances
implicit val HttpVersionShow: Show[HttpVersion]

Definition Classes
HttpVersionInstances
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
implicit val MethodInstances: Show[Method] with Equal[Method]

Definition Classes
MethodInstances
implicit def RightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]RightProjection[α, A], [α]Either[α, A]]

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

Definition Classes
EitherInstances
implicit val StatusOrder: Order[Status]

Definition Classes
StatusInstances
implicit val StatusShow: Show[Status]

Definition Classes
StatusInstances
implicit def ToCaseInsensitiveStringSyntax(cs: CharSequence): CaseInsensitiveStringOps

Definition Classes
CaseInsensitiveStringSyntax
final def ab_+[K, V](m: XMap[K, V], k: K, v: V)(implicit arg0: BuildKeyConstraint[K]): XMap[K, V]

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

Attributes
protected
Definition Classes
MapSubMap → MapSub
final def alter[K, A](m: XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

Definition Classes
MapSubFunctions
final def asInstanceOf[T0]: T0

Definition Classes
Any
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[Array[Byte]]

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
final def buildXMap[K, V, K2, V2](implicit arg0: BuildKeyConstraint[K2]): CanBuildFrom[XMap[K, V], (K2, V2), XMap[K2, V2]]

Attributes
protected
Definition Classes
MapSubMap → MapSub
implicit val byteArrayWritable: Writable[Array[Byte]]

Definition Classes
WritableInstances
implicit val byteBufferWritable: Writable[ByteBuffer]

Definition Classes
WritableInstances
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 byteVectorWritable: Writable[ByteVector]

Definition Classes
WritableInstances
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 charArrayWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[Array[Char]]

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

Definition Classes
AnyValInstances
implicit def charSequenceWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[CharSequence]

Definition Classes
WritableInstances
def chunkedWritable[A](f: (A) ⇒ Channel[Task, Int, ByteVector], chunkSize: Int = 4096): Writable[A]

Definition Classes
WritableInstances
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
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 def enumInstance[E <: Enum[E]]: Equal[E]

Definition Classes
EnumInstances
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def error(t: Throwable): EntityDecoder[Nothing]

Provides a mechanism to fail decoding
Provides a mechanism to fail decoding

Definition Classes
EntityDecoderInstances
implicit val filePathWritable: Writable[Path]

Definition Classes
WritableInstances
implicit val fileWritable: Writable[File]

Definition Classes
WritableInstances
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
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 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
implicit def futureToTask(implicit ec: ExecutionContext): ~>[Future, Task]

Definition Classes
TaskInstances
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
final def getOrAdd[F[_], K, A](m: XMap[K, A], k: K)(fa: ⇒ F[A])(implicit F: Applicative[F], K: BuildKeyConstraint[K]): F[(XMap[K, A], A)]

Definition Classes
MapSubFunctions
def hashCode(): Int

Definition Classes
AnyRef → Any
implicit def htmlWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[Elem]

Definition Classes
WritableInstances
implicit val inputStreamWritable: Writable[InputStream]

Definition Classes
WritableInstances
final def insertWith[K, A](m1: XMap[K, A], k: K, v: A)(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): 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: XMap[K, A], m2: XMap[K, B])(f: (A, B) ⇒ C)(implicit arg0: BuildKeyConstraint[K]): XMap[K, C]

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

Definition Classes
MapSubFunctions
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
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[XMap[K, V]]

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

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

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

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

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

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

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

Definition Classes
WritableInstances0
final def ne(arg0: AnyRef): Boolean

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

Definition Classes
NodeSeqInstances
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
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 processWritable[A](implicit W: Writable[A]): Writable[Process[Task, A]]

A process writable is intended for streaming, and does not calculate its bodies in advance.
A process writable is intended for streaming, and does not calculate its bodies in advance. As such, it does not calculate the Content-Length in advance. This is for use with chunked transfer encoding.

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

Supports a literal syntax for validated QValues.
Supports a literal syntax for validated QValues.
Example:
```
q(0.5).success == QValue.fromDouble(0.5)
q(1.1) // does not compile: out of range
val d = 0.5
q(d) // does not compile: not a literal
```
Definition Classes
QValueFunctions
implicit val qValueOrder: Order[QValue]

Definition Classes
QValueInstances
implicit val qValueShow: Show[QValue]

Definition Classes
QValueInstances
implicit def readerWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[Reader]

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

Definition Classes
MessageSyntax
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
implicit def showWritable[A](implicit charset: Charset = Charset.`UTF-8`, show: Show[A]): Writable[A]

Definition Classes
WritableInstances0
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 stringWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[String]

Definition Classes
WritableInstances
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
implicit val taskToFuture: ~>[Task, Future]

Definition Classes
TaskInstances
implicit def taskWritable[A](implicit W: Writable[A]): Writable[Task[A]]

Definition Classes
WritableInstances
implicit val text: EntityDecoder[String]

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

Definition Classes
EntityDecoderInstances
def toString(): String

Definition Classes
AnyRef → Any
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: XMap[K, A], m2: XMap[K, A])(f: (A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

Definition Classes
MapSubFunctions
final def unionWithKey[K, A](m1: XMap[K, A], m2: XMap[K, A])(f: (K, A, A) ⇒ A)(implicit arg0: BuildKeyConstraint[K]): 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

Literal syntax for URIs.
Literal syntax for URIs. Invalid or non-literal arguments are rejected at compile time.

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: Http4s.this.generic.IxSq[A]): Http4s.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
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def xml: EntityDecoder[Elem]

Definition Classes
EntityDecoderInstances
implicit def xml(implicit parser: SAXParser = XML.parser): EntityDecoder[Elem]

Handles a message body as XML.
Handles a message body as XML.
TODO Not an ideal implementation. Would be much better with an asynchronous XML parser, such as Aalto.
parser
the SAX parser to use to parse the XML
returns
an XML element

Definition Classes
EntityDecoderInstances

Deprecated Value Members

implicit val intMetricSpace: MetricSpace[Int]

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

trait Http4s extends Http4sInstances with Http4sFunctions with Http4sSyntax

Type Members

type BuildKeyConstraint[K] = DummyImplicit

class ParsersW[P <: Parsers] extends AnyRef

type XMap[K, V] = Map[K, V]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

val <:<: Category[<:<]

val =:=: Category[=:=]

final def ==(arg0: Any): Boolean

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

implicit val CharacterSetOrder: Order[CharsetRange]

implicit val CharsetShow: Show[Charset]

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]

implicit val HttpVersionOrder: Order[HttpVersion]

implicit val HttpVersionShow: Show[HttpVersion]

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]

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

implicit def RightProjectionAIso2[A]: scalaz.Isomorphism.<~>[[α]RightProjection[α, A], [α]Either[α, A]]

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

implicit val StatusOrder: Order[Status]

implicit val StatusShow: Show[Status]

implicit def ToCaseInsensitiveStringSyntax(cs: CharSequence): CaseInsensitiveStringOps

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

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

final def alter[K, A](m: XMap[K, A], k: K)(f: (Option[A]) ⇒ Option[A])(implicit arg0: BuildKeyConstraint[K]): XMap[K, A]

final def asInstanceOf[T0]: T0

implicit val bigDecimalInstance: Monoid[BigDecimal] with Enum[BigDecimal] with Show[BigDecimal]

implicit val bigIntInstance: Monoid[BigInt] with Enum[BigInt] with Show[BigInt]

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

implicit val bigIntegerInstance: Monoid[BigInteger] with Enum[BigInteger] with Show[BigInteger]

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

def binFile(file: File): EntityDecoder[File]

implicit val binary: EntityDecoder[Array[Byte]]

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

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

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

implicit val byteArrayWritable: Writable[Array[Byte]]

implicit val byteBufferWritable: Writable[ByteBuffer]

implicit val byteInstance: Monoid[Byte] with Enum[Byte] with Show[Byte]

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

implicit val byteVectorWritable: Writable[ByteVector]

implicit val callableMonad: Monad[Callable]

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

implicit val char: Monoid[Char] with Enum[Char] with Show[Char]

implicit def charArrayWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[Array[Char]]

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

implicit def charSequenceWritable(implicit charset: Charset = Charset.`UTF-8`): Writable[CharSequence]

def chunkedWritable[A](f: (A) ⇒ Channel[Task, Int, ByteVector], chunkSize: Int = 4096): Writable[A]

def clone(): AnyRef

implicit val doubleInstance: Order[Double] with Show[Double]

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

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

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

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

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

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

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

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

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

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

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

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

implicit val eitherInstance: Bitraverse[Either]

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

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

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

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

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

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