dsl

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

object +&

Multiple param extractor: object A extends ParamMatcher("a") object B extends ParamMatcher("b") val service: HttpService = { case GET -> Root / "user" :? A(a) +& B(b) => ...

object ->

object :?

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.type

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.type

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.type

val GatewayTimeout: Status.GatewayTimeout.type

val Gone: Status.Gone.type

val HEAD: Method.HEAD.type

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

object IntVar extends NumericPathVar[Int]

Integer extractor of a path variable: Path("/user/123") match { case Root / "user" / IntParam(userId) => ...

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

object LongVar extends NumericPathVar[Long]

Long extractor of a path variable: Path("/user/123") match { case Root / "user" / LongParam(userId) => ...

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.type

val Ok: Status.Ok.type

val PATCH: Method.PATCH.type

val POST: Method.POST.type

val PUT: Method.PUT.type

val PartialContent: Status.PartialContent.type

object Path

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

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

object Root extends Path with Product with Serializable

Root extractor: Path("/") match { case Root => ...

val SeeOther: Status.SeeOther.type

val ServiceUnavailable: Status.ServiceUnavailable.type

implicit val StatusOrder: Order[Status]

implicit val StatusShow: Show[Status]

val SwitchingProtocols: Status.SwitchingProtocols.type

val TRACE: Method.TRACE.type

val TemporaryRedirect: Status.TemporaryRedirect.type

implicit def ToCaseInsensitiveStringSyntax(cs: CharSequence): CaseInsensitiveStringOps

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]

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

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

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): Writable[Array[Char]]

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

implicit def charSequenceWritable(implicit charset: Charset): Writable[CharSequence]

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

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

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

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

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

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

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

implicit val eitherLeftInstance: IsomorphismBifunctor[LeftProjection, Either]

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

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

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

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

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] }

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

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

implicit val eitherRightInstance: IsomorphismBifunctor[RightProjection, Either]

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

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

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

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

implicit def enumInstance[E <: Enum[E]]: Equal[E]

def error(t: Throwable): EntityDecoder[Nothing]

implicit val filePathWritable: Writable[java.nio.file.Path]

implicit val fileWritable: Writable[File]

implicit val floatInstance: Order[Float] with Show[Float]

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

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

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

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

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

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

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

implicit val function1Instance: Arrow[Function1] with Category[Function1] with Choice[Function1]

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

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

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

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

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

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

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

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

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

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

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

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

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

implicit def futureToTask(implicit ec: ExecutionContext): ~>[Future, Task]

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)]

implicit def htmlWritable(implicit charset: Charset): Writable[Elem]

package impl

implicit val inputStreamWritable: Writable[InputStream]

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]

implicit val intInstance: Monoid[Int] with Enum[Int] with Show[Int]

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

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]

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]

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

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 }

implicit def listMonoid[A]: Monoid[List[A]]

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

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

implicit val longInstance: Monoid[Long] with Enum[Long] with Show[Long]

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

implicit val mapEntryBitraverse: Bitraverse[Entry]

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

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

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

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]

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

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

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

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

implicit val nodeSeqInstance: Monoid[NodeSeq] with Show[NodeSeq] with Equal[NodeSeq]

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

implicit def optionFirst[A]: Monoid[FirstOption[A]]

implicit def optionFirstMonad: Monad[FirstOption]

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

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

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 */ }

implicit def optionLast[A]: Monoid[LastOption[A]]

implicit def optionLastMonad: Monad[LastOption]

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

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

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

implicit def optionMaxMonad: Monad[MaxOption]

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

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

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

implicit def optionMinMonad: Monad[MinOption]

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

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

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

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

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

def orderingMonoid[A]: Monoid[Ordering[A]]

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

implicit val partialFunctionInstance: Arrow[PartialFunction] with Category[PartialFunction] with Choice[PartialFunction]

implicit def processWritable[A](implicit W: Writable[A]): Writable[Process[Task, A]]

macro def q(d: Double): QValue

implicit val qValueOrder: Order[QValue]

implicit val qValueShow: Show[QValue]

implicit def readerWritable(implicit charset: Charset): Writable[Reader]

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

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

implicit val setInstance: Foldable[Set] with IsEmpty[Set] with Length[Set]

implicit def setMonoid[A]: Monoid[Set[A]]

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

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

implicit val shortInstance: Monoid[Short] with Enum[Short] with Show[Short]

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

implicit def showWritable[A](implicit charset: Charset, show: Show[A]): Writable[A]

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

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]

implicit def streamMonoid[A]: Monoid[Stream[A]]

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

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

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

implicit def stringWritable(implicit charset: Charset): Writable[String]

implicit val taskToFuture: ~>[Task, Future]

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

implicit val text: EntityDecoder[String]

def textFile(in: File): EntityDecoder[File]

implicit val tuple1Cozip: Cozip[Tuple1]

implicit def tuple1Equal[A1](implicit A1: Equal[A1]): Equal[(A1)]

implicit val tuple1Instance: Traverse[Tuple1] with Monad[Tuple1] with Comonad[Tuple1]

implicit def tuple1Monoid[A1](implicit A1: Monoid[A1]): Monoid[(A1)]

implicit def tuple1Order[A1](implicit A1: Order[A1]): Order[(A1)]

implicit def tuple1Semigroup[A1](implicit A1: Semigroup[A1]): Semigroup[(A1)]

implicit def tuple1Show[A1](implicit A1: Show[A1]): Show[(A1)]

implicit val tuple2Bitraverse: Bitraverse[Tuple2]

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

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

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

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

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

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

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

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

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

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

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

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

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

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