Scalaz，*语法类的目的

Question

In scalaz when we define a module, we additionally define implicit, helper functions. Here is an example of definition and how it could be used by a client:

trait Functor[F[_]] {
  def map[A,B](fa: F[A])(f: A => B): F[B]
}
object Functor {
  def fmap[F[_], A,B](as:F[A])(f:A=>B)
                    (implicit ff:Functor[F]):F[B] =
    ff.map(as)(f)

  implicit val listFunctor = new Functor[List] {
    def map[A,B](as: List[A])(f: A => B): List[B] = as map f
  }
}
...
import com.savdev.NewLibrary._
val r = fmap(List(1,2))(_.toString)

final class FunctorOps[F[_], A](self: F[A])(implicit ff:Functor[F]){
  def qmap[B](f:A=>B):F[B] = ff.map(self)(f)
}
trait ToFunctorOps {
  implicit def ToFunctorOps[F[_],A](v: F[A])(implicit F0: Functor[F]) =
    new FunctorOps[F,A](v)
}
object NewLibrary extends ToFunctorOps
...
import com.savdev.NewLibrary._
val r2 = List(1, 4) qmap (x=>x.toString)

The code is slightly changed. But the idea is that we define:

1. An abstraction and its API (algebra)
2. Define helper generic functions that use implicits and implicits themselves
3. Enrich existing types to be able to use our new abstraction. Implicit convertion is used for that. In scalaz we define a final class for a wrapper and implicit converters in traits

All above, the motivation of it and how it can be used by a client is clear. But in scalaz to each such module definition, there is also a related *Syntax class. I cannot understand the purpose of it. Can you please exlain, why it is needed and HOW it can be used in a client code.

In Scalaz it is defined as:

trait FunctorSyntax[F[_]] {
  implicit def ToFunctorOps[A](v: F[A]): FunctorOps[F, A] =
    new FunctorOps[F, A](v)(FunctorSyntax.this.F)
  def F: Functor[F]
}

UPDATED:

Guys, it seems I am not clear enough, or a topic is more complicated for all of us.

What I need is to understand the difference between two traits:

trait ToFunctorOps {
  implicit def ToFunctorOps[F[_],A](v: F[A])(implicit F0: Functor[F]) =
    new FunctorOps[F,A](v)
}

vs.

trait FunctorSyntax[F[_]] {
  implicit def ToFunctorOps[A](v: F[A]): FunctorOps[F, A] =
    new FunctorOps[F, A](v)(FunctorSyntax.this.F)
  def F: Functor[F]
}

Both traits define a generic method that creates FunctorOps , both have the same visibility rules. The first ToFunctorOps trait, it is not generic itself, it defines only generic method with [F[_],A] . As a result, I can compose a lot of such traits into one object and import all of them at once. I gave an example how such traits could be used by a client:

object NewLibrary extends ToFunctorOps
...
import com.savdev.NewLibrary._
val r2 = List(1, 4) qmap (x=>x.toString)

This trait already gives clients a possibility to inject methods implicitly. Why do we need FunctorSyntax ? This FunctorSyntax trait is a generic itself on [F[_]] . When I extend it, I must provide a type in the definition. Because F[_] now is used in trait definition, a function has less generic parameters, only [A] .

I am asking you guys, if you can help and undestand, give me a code example how this FunctorSyntax trait can be used by a client. Exactly this is not clear.

Right now I see tries to explain the other topics, but not the original:

1. How to create implicit classes, instead of implicit functions.
2. Difference between final *Ops class and a trait, including their visibility. Here we compare 2 traits with the same visibility.
3. Explaining in general method injection, how they help. This functionality is provided already with ToFunctorOps .

Guys, again, please show the community USE CASES via CODE of FunctorSyntax . Code itself is always the best documentation.

Best regards

Answer 1

From what I can see in the scalaz codebase, I think that FunctorSyntax is meant as an alternative way of enabling syntax. They define Functor like this (simplified):

trait Functor {
  def map[A, B](fa: F[A])(f: A => B): F[B]

  val functorSyntax = new FunctorSyntax[F] { def F = Functor.this }
}

This enables the following way of working:

def foo[F[_]](f: F[String])(implicit F: Functor[F]): F[Int] = {
  import F.functorSyntax._
  f.map(_.length)
}

Compare to how ToFunctorOps adds syntax:

package scalaz.syntax { // simplified version of the scalaz codebase
  object functor extends ToFunctorOps 
}

import scalaz.syntax.functor._
def foo[F[_]: Functor](f: F[String]): F[Int] = f.map(_.length)

Answer 2

Here's a use case where you would use functorSyntax:

import org.scalatest.{FreeSpec, Matchers}

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.{Await, Future}
import scala.concurrent.duration._
import scalaz._
import Scalaz._

import scala.language.postfixOps

class ScalazTest extends FreeSpec with Matchers {
  "compose functors" in {
    val composedFunctor = Functor[Future] compose Functor[List] compose Functor[Option]
    import composedFunctor.functorSyntax._

    val actual = Future.successful(List(Some(1), Some(2), None, Some(4))) fmap (x => x * 2)
    Await.result(actual, 10 seconds) shouldBe List(Some(2), Some(4), None, Some(8))
  }
}

The idea is that you can compose several functor instaces and import the final composed functor's instance in scope and work with it. Notice that fmap is resolved to composedFunctor.functorSyntax in this case and it works on 3 levels of nesting ( Future[List[Option[Integer]]] ) while still accepting a function that deals with primitive types.