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[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
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 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 = Charset.`UTF-8`): 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 = Charset.`UTF-8`): EntityEncoder[CharSequence]

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

Definition Classes
EntityEncoderInstances
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 val entityEncoderContravariant: Contravariant[EntityEncoder]

Definition Classes
EntityEncoderInstances
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](t: Throwable): EntityDecoder[T]

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

Definition Classes
EntityDecoderInstances
implicit val fileEncoder: EntityEncoder[File]

Definition Classes
EntityEncoderInstances
implicit val filePathEncoder: EntityEncoder[Path]

Definition Classes
EntityEncoderInstances
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 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
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 inputStreamEncoder[A <: InputStream]: EntityEncoder[A]

Definition Classes
EntityEncoderInstances
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 naturalTransformationEncoder[F[_], A](implicit N: ~>[F, Task], W: EntityEncoder[A]): EntityEncoder[F[A]]

Definition Classes
EntityEncoderInstances0
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 process0Encoder[A](implicit W: EntityEncoder[A]): EntityEncoder[Process0[A]]

Definition Classes
EntityEncoderInstances0
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 readerEncoder[A <: Reader](implicit charset: Charset = Charset.`UTF-8`): EntityEncoder[A]

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

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

Resolve a relative Uri reference, per RFC 3986 sec 5.2
Resolve a relative Uri reference, per RFC 3986 sec 5.2

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 = Charset.`UTF-8`, show: Show[A]): EntityEncoder[A]

Encodes a value from its Show instance.
Encodes a value from its Show instance. Too broad to be implicit, too useful to not exist.

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

A process encoder is intended for streaming, and does not calculate its bodies in advance.
A process encoder 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
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 = Charset.`UTF-8`): EntityEncoder[String]

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

Definition Classes
AnyRef
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
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( ... )

Deprecated Value Members

implicit val intMetricSpace: MetricSpace[Int]

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

Related Docs: object Http4s | package http4s

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[ByteVector]

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

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

implicit object booleanInstance extends Enum[Boolean] with Show[Boolean]

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

implicit val byteArrayEncoder: EntityEncoder[Array[Byte]]

implicit val byteBufferEncoder: EntityEncoder[ByteBuffer]

implicit val byteEncoder: EntityEncoder[Byte]

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

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

implicit val byteVectorEncoder: EntityEncoder[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 charArrayEncoder(implicit charset: Charset = Charset.`UTF-8`): EntityEncoder[Array[Char]]

implicit val charEncoder: EntityEncoder[Char]

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

implicit def charSequenceEncoder[A <: CharSequence](implicit charset: Charset = Charset.`UTF-8`): EntityEncoder[CharSequence]

def chunkedEncoder[A](f: (A) ⇒ Channel[Task, Int, ByteVector], chunkSize: Int = 4096): EntityEncoder[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]]