Enregistrement dans le tutoriel FS2, je suis tombé sur le code suivant

def client[F[_]: MonadCancelThrow: Console: Network]: F[Unit] =
  Network[F].client(SocketAddress(host"localhost", port"5555")).use { socket =>
    socket.write(Chunk.array("Hello, world!".getBytes)) >>
      socket.read(8192).flatMap { response =>
        Console[F].println(s"Response: $response")
      }
  }

Network[F].client

Sentirait bizarre comme je voudrais normalement écrire

implictly[Network[F]].client

J'ai donc vérifié le code et cela fonctionne et compilez, de sorte que cela ne doit plus être implicitement nécessaire. Je me demande depuis quand? Est-ce que ça va être obsolète? Quelqu'un peut-il partager le lien vers les notes de version Scala ou quelque chose qui indique cela?

4
MaatDeamon 4 mai 2021 à 12:47

2 réponses

Meilleure réponse

C'est juste une convention suivie de nombreuses bibliothèques: si FooBar[K] est une sorte de typlass, on définit généralement une méthode apply sur l'objet compagnon, avec une signature qui ressemble quelque peu à ceci:

object FooBar {
  def apply[K](implicit ev: FooBar[K]): FooBar[K] = ev
}

Ou peut-être (si on veut avoir un type plus précis, en particulier si on veut avoir accès à des membres de type de { {X0}}), comme ceci:

object FooBar {
  def apply[K](implicit ev: FooBar[K]): ev.type = ev
}

Permettant ainsi d'écrire des expressions au niveau de la valeur qui ressemblent exactement au type de l'expression:

FooBar[K]: FooBar[K] // desugars into FooBar.apply[F](<implicit instance>)

Voici cette méthode en Network (Lien vers Github, les commentaires sont les miennes):

def apply[F[_]](implicit F: Network[F]): F.type = F
//        ^--- type-constructor
//                       ^--- value
//                                  ^--- type-constructor
//                                       ^--- value
//                                                ^--- value

Cette convention est indépendante et généralement non affectée par la variation implicitly / summon de Scala 3.

8
Andrey Tyukin 4 mai 2021 à 14:27

implicitly n'est pas obsolète.

Il y a un motif, généralement vu dans l'écosystème Typelevel, dont FS2 est un, d'avoir la méthode apply dans l'objet compagnon Son Synonyme de implicitly, qui permet au code d'utilisateur de ne pas utiliser {{ X2}}.

5
Levi Ramsey 4 mai 2021 à 22:56