7
votes

Pourquoi une telle définition de l'opérateur est-elle possible dans Scala?

J'utilise F # et je ne sais pas beaucoup de scala, sauf qu'il y a souvent des similitudes entre ces langues. Mais tout en regardant la mise en œuvre d'Akka Streams à Scala, j'ai remarqué l'utilisation de l'opérateur ~> de telle manière qui n'est pas possible dans F # (malheureusement). Je ne parle pas de symbole "~" qui ne peut être utilisé que dans F # au début des opérateurs unaires, ce n'est pas important. Ce qui m'a impressionné, c'est la possibilité de définir des graphiques comme celui-ci: xxx

puisque divers éléments de graphique ont différents types (source, flux, évier), il n'est pas possible de définir un seul opérateur dans F # qui fonctionnerait à travers eux. Mais je me demande pourquoi cela est possible dans Scala - cela, car Scala prend en charge la surcharge de la fonction (et F # ne)?

Mise à jour. Fydor Soikin a montré plusieurs façons de surcharger dans F # pouvant être utilisée pour obtenir une syntaxe similaire lors de l'utilisation de F #. J'ai essayé cela et ici comment cela pourrait regarder: xxx

Nous pouvons maintenant écrire le code suivant: xxx


1 commentaires

F # Totalement la surcharge de la méthode de support.


3 Réponses :


7
votes

Vous pouvez définir des opérateurs en tant que membres de la classe si nécessaire xxx


0 commentaires

10
votes

En réalité, Scala a au moins quatre façons différentes de le faire fonctionner.

(1) surcharge de la méthode. p> xxx pré>

(2) héritage. P>

def ~>(s: Streamable) = ???


1 commentaires

Merci pour une excellente explication.



6
votes

Tout d'abord, F # prend totalement la surcharge de la méthode de support:

type Base() = class end
type A() = inherit Base()
type B() = inherit Base()

let (===>) (a: #Base) (b: #Base) = Base()

let g = A() ===> B() ===> A()


4 commentaires

Vous avez bien sûr la surcharge de la méthode. Ce que je veux dire, c'était la surcharge de fonction et la référencée de manière incorrecte en tant que surcharge de la méthode. Apparemment, l'incapacité de définir des opérateurs similaires (à Scala) F # pour les flux AKKA provient du fait que l'AKKA a été porté dans .NET à C #, il y a donc très peu de liberté dans ce qui peut être fait en F # dans les classes Akka.net. Avait-il été port à F # en premier lieu, alors je suppose qu'il y aura plus d'opportunités.


Vous pouvez également faire une surcharge de fonction (dans une certaine mesure), comme je l'ai montré dans les exemples ci-dessus.


Oui, tu as encore raison. C'est possible via la définition de type.


J'ai passé plus de temps à jouer avec vos suggestions, et ils fonctionnent très bien, avec votre proposition concernant la surcharge de la deuxième argument, je suis capable d'obtenir une syntaxe similaire à la manière dont ils l'utilisent à Scala. Merci beaucoup!