Packages

object Functors extends CompositeFunctors

Functor and Traverse typeclasses for Tuples, HLists and Compositions of Functors, and for Constant functors.

To work around ambiguity in inference, for example so that the type of iterated triples is interpreted as III(A) = (II(A), Id(A)), not III(A) = ((A, A), A) several functors are explicitly named with the appropriate structure.

Linear Supertypes
CompositeFunctors, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Functors
  2. CompositeFunctors
  3. AnyRef
  4. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Type Members

  1. type C[A, X] = X

    constant functor X

  2. type Coded[A] = (S[A], IL[A])

    triple (String, (Int(A), List(A)))

  3. type HN[A] = HNil

    Constant HNil functor

  4. type II[A] = (Id[A], Id[A])

    Identity product itself

  5. type III[A] = (II[A], Id[A])

    triple (Id(A), (Id(A), Id(A)))

  6. type IIIV[A] = (Id[A], IIV[A])

    4-tuple (Id(A), (Id(A), (Id(A), Vector(A))))

  7. type IIV[A] = (Id[A], IV[A])

    triple (Id(A), (Id(A), Vector(A)))

  8. type IL[A] = (Id[A], List[A])

    Identity product with List

  9. type IV[A] = (Id[A], Vector[A])

    Identity product Vector

  10. type IVI[A] = (Id[A], VI[A])

    triple (Id(A), (Vector(A), Id(A)))

  11. type IVIIV[A] = (Id[A], VIIV[A])

    5-tuple (Id(A), (Vector(A), (Id(A), (Id(A), Vector(A)))))

  12. type IdHN[A] = ::[Id[A], HN[A]]

    Identity product HNil

  13. type IdIdHN[A] = ::[Id[A], IdHN[A]]

    Pair of Identity functors product HNil

  14. type IdIdIdHN[A] = ::[Id[A], IdIdHN[A]]

    Three copies of Identity Functor product HNil

  15. type In[A] = Int

    Constant Int functor

  16. type InHN[A] = ::[In[A], HN[A]]

    Product of Int with HNil

  17. type LL[A] = (List[A], List[A])

    pair of Lists

  18. type N[A] = Int

    constant Int functor

  19. type Named[A] = (S[A], Id[A])

    Functor identity with a name

  20. type Numbered[A] = (N[A], Id[A])
  21. type Pickled = (S[String], IL[String])
  22. type S[A] = String

    constant String functor

  23. type SV[A] = (S[A], Vector[A])

    pair (String, Vector(A))

  24. type SVI[A] = (S[A], VI[A])

    triple (String, (Vector(A), Id(A)))

  25. type SVII[A] = (S[A], VII[A])

    4-tuple (String, (Vector(A), (Id(A), Id(A))))

  26. type SVO[A] = (S[A], VO[A])

    triple (String, (Vector(A), Option(A)))

  27. type St[A] = String

    Constant String Functor

  28. type StHN[A] = ::[St[A], HN[A]]

    String product with HNil

  29. type StIdHN[A] = ::[St[A], IdHN[A]]

    Triple (String, (A, HNil))

  30. type StIntHN[A] = ::[St[A], InHN[A]]

    triple (String, (Int, HNil))

  31. type Un[A] = Unit

    constant Unit functor

  32. type VI[A] = (Vector[A], Id[A])

    Vector product Identity

  33. type VII[A] = (Vector[A], II[A])

    triple (Vector(A), (Id(A), Id(A)))

  34. type VIIV[A] = (Vector[A], IIV[A])

    4-tuple (Vector(A), (Id(A), (Id(A), Vector(A))))

  35. type VIVIIV[A] = (Vector[A], IVIIV[A])
  36. type VO[A] = (Vector[A], Option[A])

    Vector product Option

  37. type VV[A] = (Vector[A], Vector[A])

    pair of Vectors

Value Members

  1. implicit def augmentedFunctor[Cn, X[_]](implicit arg0: Functor[X]): Functor[[A](Cn, X[A])]

    functor by product with a constant functor

  2. implicit def composeFunctors[X[_], Y[_]](implicit arg0: Functor[X], arg1: Functor[Y]): Functor[[A]X[Y[A]]]

    composition of functors is a functor

  3. implicit def constantFunctor[Cn]: Functor[[A]Cn]

    constant functor

  4. def liftMap[A, B, F[_]](fa: F[A], f: (A) => B)(implicit arg0: Functor[F]): F[B]

    induced map, should use cats syntax instead

  5. implicit val namedTrav: Traverse[Named]

    Traverse type class for identity with name

  6. implicit val numberedTrav: Traverse[Numbered]
  7. implicit def t2[X[_], Y[_]](implicit arg0: Functor[X], arg1: Functor[Y]): Functor[[A](X[A], Y[A])]

    functor for pairs

  8. implicit def trCnst[X]: Traverse[[A]X]

    Traverse typeclass for Constant functors

  9. implicit def trCod: Traverse[Coded]
  10. implicit def traverseCompose[X[_], Y[_]](implicit arg0: Traverse[X], arg1: Traverse[Y]): Traverse[[A]X[Y[A]]]

    Traverse type class for composition

    Traverse type class for composition

    Definition Classes
    CompositeFunctors
  11. implicit def traverseEquiv[F[_], Y[_]](implicit equiv: Equiv[F, Y], TY: Traverse[Y]): Traverse[F]

    Traverse class induced by equivalence of Functors

  12. implicit def traverseHCons[X[_], Y[_] <: HList](implicit tx: Lazy[Traverse[X]], YT: Traverse[Y]): Traverse[[A]::[X[A], Y[A]]]

    Travese typeclass for HCons

    Travese typeclass for HCons

    Definition Classes
    CompositeFunctors
  13. implicit def traversePair[X[_], Y[_]](implicit arg0: Traverse[X], arg1: Traverse[Y]): Traverse[[A](X[A], Y[A])]

    traverse class for pairs