rho

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

def *: CaptureTail.type

val <:<: Category[<:<]

val =:=: Category[=:=]

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]

val PathEmpty: PathRule

object Result extends Serializable

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

object UriConvertible

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

package bits

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

def capture[H <: Extractable](key: H): TypedHeader[::[rho.capture.H.HeaderT, HNil]]

requires the header and will pull this header from the pile and put it into the function args stack

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

implicit def charArrayEncoder(implicit charset: Charset): 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): EntityEncoder[CharSequence]

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

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

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

implicit val fileEncoder: EntityEncoder[File]

implicit val filePathEncoder: EntityEncoder[Path]

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 futureEncoder[A](implicit W: EntityEncoder[A], ec: ExecutionContext): EntityEncoder[Future[A]]

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

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

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 method(m: Method): PathBuilder[HNil]

implicit def naturalTransformationEncoder[F[_], A](implicit N: ~>[F, Task], W: EntityEncoder[A]): EntityEncoder[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 param[T](name: String, default: T, validate: (T) ⇒ Boolean = (_: T) => true)(implicit parser: QueryParser[T], m: scala.reflect.api.JavaUniverse.TypeTag[T]): TypedQuery[::[T, HNil]]

Defines a parameter in query string that should be bound to a route definition.

def param[T](name: String)(implicit parser: QueryParser[T], m: scala.reflect.api.JavaUniverse.TypeTag[T]): TypedQuery[::[T, HNil]]

Defines a parameter in query string that should be bound to a route definition.

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 pathMatch(s: Symbol): TypedPath[::[String, HNil]]

implicit def pathMatch(s: String): TypedPath[HNil]

def pathVar[T](id: String)(implicit parser: StringParser[T], m: scala.reflect.api.JavaUniverse.TypeTag[T]): TypedPath[::[T, HNil]]

Defines a path variable of a URI that should be bound to a route definition

def pathVar[T](implicit parser: StringParser[T], m: scala.reflect.api.JavaUniverse.TypeTag[T]): TypedPath[::[T, HNil]]

Defines a path variable of a URI that should be bound to a route definition

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

macro def q(d: Double): QValue

implicit val qValueOrder: Order[QValue]

implicit val qValueShow: Show[QValue]

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

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

def require(header: Extractable): TypedHeader[HNil]

def requireMap[H <: Extractable, R](key: H)(f: (rho.requireMap.H.HeaderT) ⇒ R): TypedHeader[::[R, HNil]]

def requireThat[H <: Extractable](header: H)(f: (rho.requireThat.H.HeaderT) ⇒ Boolean): TypedHeader[HNil]

def resolve(base: Uri, reference: Uri): Uri

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

def root(): TypedPath[HNil]

Helper to be able to define a path with one level only.

val hello = Root / "hello"

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

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

implicit def sourceEncoder[A](implicit W: EntityEncoder[A]): EntityEncoder[Process[Task, 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 def stringEncoder(implicit charset: Charset): EntityEncoder[String]

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

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

implicit val text: EntityDecoder[String]

def textFile(file: 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)]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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