| career | drupal | java | mac | mysql | perl | scala | uml | unix  

Scala example source code file (TracedT.scala)

This example Scala source code file (TracedT.scala) is included in the "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Scala by Example" TM.

Learn more about this Scala project at its project page.

Java - Scala tags/keywords

apply, cobind, comonad, distributive, functor, monoid, tracedt, tracedtfunctor

The TracedT.scala Scala example source code

package scalaz

 * @see [[]]
final case class TracedT[W[_], A, B](run: W[A => B]) {
  def map[C](f: B => C)(implicit W: Functor[W]): TracedT[W, A, C] =
    TracedT( andThen f))

  def cobind[C](f: TracedT[W, A, B] => C)(implicit W: Cobind[W], A: Semigroup[A]): TracedT[W, A, C] =
      W.extend(run) { wf => m =>
        f(TracedT(, m)))))

  def trans[M[_]](f: W ~> M): TracedT[M, A, B] =

  def copoint(implicit W: Comonad[W], A: Monoid[A]): B =

  def lower(implicit W: Functor[W], A: Monoid[A]): W[B] = apply

  def contramap[C](f: C => A)(implicit W: Functor[W]): TracedT[W, C, B] =

sealed abstract class TracedTInstances5 {
  implicit final def tracedTFunctor[W[_]: Functor, C]: Functor[TracedT[W, C, ?]] =
    new TracedTFunctor[W, C]{
      def W = implicitly

  implicit final def tracedTContravariant[W[_]: Functor, C]: Contravariant[TracedT[W, ?, C]] =
    new Contravariant[TracedT[W, ?, C]]{
      override def contramap[A, B](r: TracedT[W, A, C])(f: B => A) =
        r contramap f

sealed abstract class TracedTInstances4 extends TracedTInstances5 {
  implicit final def tracedTDistributive[W[_]: Distributive, C]: Distributive[TracedT[W, C, ?]] =
    new TracedTDistributive[W, C] {
      def W = implicitly

sealed abstract class TracedTInstances3 extends TracedTInstances4 {
  implicit final def tracedTApply[W[_]: Apply, C]: Apply[TracedT[W, C, ?]] =
    new TracedTApply[W, C]{
      def W = implicitly

sealed abstract class TracedTInstances2 extends TracedTInstances3 {
  implicit final def tracedTApplicative[W[_]: Applicative, C]: Applicative[TracedT[W, C, ?]] =
    new TracedTApplicative[W, C]{
      def W = implicitly

sealed abstract class TracedTInstances1 extends TracedTInstances2 {
  implicit final def tracedTCobind[W[_]: Cobind, C: Semigroup]: Cobind[TracedT[W, C, ?]] =
    new TracedTCobind[W, C]{
      def W = implicitly
      def C = implicitly

sealed abstract class TracedTInstances0 extends TracedTInstances1 {

  implicit final def tracedTComonad[W[_]: Comonad, C: Monoid]: Comonad[TracedT[W, C, ?]] =
    new TracedTComonad[W, C]{
      def W = implicitly
      def C = implicitly

  implicit final def tracedTCohoist[C: Monoid]: Cohoist[Lambda[(w[_], b) => TracedT[w, C, b]]] =
    new Cohoist[Lambda[(w[_], b) => TracedT[w, C, b]]] {
      override def cohoist[M[_], N[_]: Comonad](f: M ~> N) =
        new (TracedT[M, C, ?] ~> TracedT[N, C, ?]) {
          def apply[A](fa: TracedT[M, C, A]) = fa.trans(f)
      override def lower[G[_], A](a: TracedT[G, C, A])(implicit G: Cobind[G]) =

  implicit final def tracedTEqual[W[_], A, B](implicit W: Equal[W[A => B]]): Equal[TracedT[W, A, B]] =


sealed abstract class TracedTInstances extends TracedTInstances0 {

  implicit final def tracedTComonadStore[W[_], S, C: Monoid](implicit W0: ComonadStore[W, S]): ComonadStore[TracedT[W, C, ?], S] =
    new ComonadStore[TracedT[W, C, ?], S] with TracedTComonad[W, C] {
      def W = W0
      def C = implicitly
      override def pos[A](w: TracedT[W, C, A]) =
      override def peek[A](s: S, w: TracedT[W, C, A]) =
        W0.peek(s, TracedT.tracedTCohoist[C].lower(w))


object TracedT extends TracedTInstances {

  def tracedTU[WAB, AB, A0, B0](wab: WAB)(implicit
    U1: Unapply[Functor, WAB]{type A = AB},
    U2: Unapply2[Profunctor, AB]{type A = A0; type B = B0},
    L: Leibniz.===[AB, A0 => B0]
  ): TracedT[U1.M, A0, B0] = TracedT(L.subst[U1.M](U1(wab)))

  import scalaz.Isomorphism._

  def iso[W[_]]: TracedT[W, ?, ?] <~~> Lambda[(a, b) => W[a => b]] =
    new IsoBifunctorTemplate[TracedT[W, ?, ?], Lambda[(a, b) => W[a => b]]] {
      override def to[A, B](fa: TracedT[W, A, B]) =
      override def from[A, B](ga: W[A => B]) = TracedT(ga)


private trait TracedTFunctor[W[_], C] extends Functor[TracedT[W, C, ?]] {
  implicit def W: Functor[W]

  override final def map[A, B](fa: TracedT[W, C, A])(f: A => B) =
    fa map f

private trait TracedTDistributive[W[_], C] extends Distributive[TracedT[W, C, ?]] with TracedTFunctor[W, C] {
  def W: Distributive[W]

  import scalaz.std.function._

  override final def distributeImpl[G[_], A, B](fa: G[A])(f: A => TracedT[W, C, B])(implicit G: Functor[G]) =
        Distributive[C => ?].cosequence(_)

private trait TracedTApply[W[_], C] extends Apply[TracedT[W, C, ?]] with TracedTFunctor[W, C] {
  def W: Apply[W]

  override final def ap[A, B](fa: => TracedT[W, C, A])(f: => TracedT[W, C, A => B]) =
      W.ap( => ca => c => cab(c).apply(ca(c)))

private trait TracedTApplicative[W[_], C] extends Applicative[TracedT[W, C, ?]] with TracedTApply[W, C] {
  def W: Applicative[W]

  override final def point[A](a: => A) = TracedT(W.point(Function.const(a)))

private trait TracedTCobind[W[_], C] extends Cobind[TracedT[W, C, ?]] with TracedTFunctor[W, C] {
  implicit def W: Cobind[W]
  implicit def C: Semigroup[C]

  override final def cobind[A, B](fa: TracedT[W, C, A])(f: TracedT[W, C, A] => B) =
    fa cobind f

private trait TracedTComonad[W[_], C] extends Comonad[TracedT[W, C, ?]] with TracedTCobind[W, C] {
  implicit def W: Comonad[W]
  implicit def C: Monoid[C]

  override final def copoint[A](p: TracedT[W, C, A]): A =

Other Scala examples (source code examples)

Here is a short list of links related to this Scala TracedT.scala source code file:

... this post is sponsored by my books ...

#1 New Release!

FP Best Seller


new blog posts


Copyright 1998-2021 Alvin Alexander,
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.