Was ist F[_] in Scala?

Das Typsystem von Scala ist eines der ausgefeiltesten Typsysteme. Für Menschen, die versuchen, diese schöne Sprache zu erlernen, kann es kompliziert sein zu verstehen, was diese Typen sind.

Einer dieser Typen ist der F[]. Ich erinnere mich, dass ich verwirrt war und mich fragte, was es war und warum ich es überhaupt brauchte. Zu dieser Verwirrung trugen auch die verschiedenen Namen bei, die die [] in F[_] in der Scala-Gemeinschaft. Einige Ingenieure nennen es wildcard, one slot, oder hole, während andere es als joker box.

  trait Traverse[F[_]] {
        def traverse[G[_]: Applicative, A, B](fa: F[A])(f: A => G[B]): G[F[B]]
    }

Verwirrend, oder? Machen Sie sich keine Sorgen!

In diesem Blog werde ich mein Bestes geben, um Ihnen zu erklären, was es ist und warum Sie es überhaupt brauchen.

Bevor wir verstehen können, was F[_] ist, müssen wir zunächst die Typen in Scala verstehen.

Scala hat proper types, oder wie ich sie nennen würde, level zero Typen, wie zum Beispiel Int, Float, Double, und String. Ebene zero types oder proper types sind Typen, die selbst an einen Wert angehängt werden können. Deshalb ist es möglich zu sagen:

val company : String = "47 Degrees"

val magicNumber: Int = 47

Was ist mit List, Option, Either, und Map? Was sind sie? Nun, sie sind das, was wir als first-order Typen oder level one Typen, weil sie selbst nicht mit einem Wert verbunden werden können. Wenn wir den folgenden Ausdruck an den Scala-Compiler geben, erhalten wir eine Fehlermeldung:

val countries: List = List("  ", "  ", " ", " ", " " )

1 |val countries: List = List("  ", "  ", " ", " ", " " )
| ^^^^
| Missing type parameter for List

Das liegt daran, dass die Sprache uns nicht erlaubt, die Option List als Typ. Es will, dass wir eine Liste von etwas sagen List[_].

Damit dies kompiliert werden kann, müssen wir die List a level zero Typ oder eine proper type. Aus diesem Grund würde das obige Beispiel lauten:

val countries: List[String] = List("  ", "  ", " ", " ", " " )

Das bedeutet, dass Typen erster Ordnung oder Typen der Ebene eins wie List, Option, Map, und Either sind generic types mit einem Typ-Konstruktor [_] die einen eigenen Typ oder einen Typ der Stufe Null annimmt, Int, String, Floatusw., um andere Typen der Stufe Null zu erzeugen.

List // This is a level one type

und

List[Int] // This is a level zero type

Wir haben zwei neue Wörter erwähnt, Type Constructor und Generic Types , die wir verstehen müssen.

Was ist ein generischer Typ?

Angenommen, wir hätten eine Klasse namens MyStack

class MyStack[A] {

    //some code here
}

Wir sagen, dass MyStack generisch ist, weil jeder Code, den wir innerhalb der Klasse MyStack schreiben, innerhalb der Klasse {} für jeden Typ A funktionieren wird.

Sie können sich vorstellen class MyStack[A] als Vorlage, um viele Klassen gleichzeitig zu definieren: Wenn Sie MyStack[Double] oder MyStack[Int] schreiben, erhalten Sie eine copy von MyStack in dem jeder A hat sich zu einem Double, oder ein Intbeziehungsweise. Das ist es, was wir in diesem Fall unter einem generischen Typ verstehen.

Was ist ein Typkonstruktor [_] oder ein höherer Typ?

Ein Typkonstruktor ist so etwas wie eine Funktion, die einen Typ als Argument annimmt und einen Typ zurückgibt.

(Int) => Int  

or

String => String

Ein Konstruktor vom Typ List[_] ist also einfach eine Funktion vom Typ

(A) => List[A]

oder

String => List[String]

Jetzt, wo wir wissen, was wir tun müssen

• Ein proper oder level zero Typ in Scala ist, auch bekannt als String , Int , Float , usw.
• A first order oder level one Typ in Scala ist, auch bekannt als List, Option, Map, Either.
• Ein Typkonstruktor ([_]) ist eine Funktion, die einen Typ annimmt und einen Typ zurückgibt. String => String

können wir uns endlich ansehen, was die F[] ist in Scala. Die F[] bedeutet einfach, dass F ist eine type parameter, die selbst eine type constructor oder einen Typ mit einem type parameter. Wie wir bereits erwähnt haben, kann ein solcher Typ ein List,Option, oder sogar ein Scala Future. Verwendung von F[_] ist eine Möglichkeit, über Typen der Ebene eins zu abstrahieren, so dass sie alle gemeinsame Funktionen haben, damit wir diese Funktionen nicht für List, Option, Future, etc.

Das Leben wäre ziemlich langweilig, wenn wir uns immer nur wiederholen müssten.

Nehmen wir an, wir haben eine My47Degrees Klasse, die einen Typ der Stufe 1 annimmt. Wir könnten etwas in dieser Art schreiben:

class My47Degrees[F[_]] {
    def map[A, B](fa: F[A])(f:A => B): F[B]
}

Das bedeutet, dass wir F[_] durch einen beliebigen Typ der Stufe 1 ersetzen und eine gemeinsame Methode namens map verwenden können:

new My47Degrees[List] oder new My47Degrees[Option]

Ohne die hätten wir so etwas wieF[_] gemacht:

class My47DegreesForList {
    def map[A, B](fa: List[A])(f:A => B): List[B]
}

class My47DegreesForOption {
    def map[A, B](fa: Option[A])(f:A => B): Option[B]
}

Ist das nicht schön? Wir haben soeben über alles abstrahiert first-order Typen mit einer ähnlichen Funktion namens map. Und dafür müssen wir die F[_] Parameter. Das war's.

Denken Sie über die Vorteile nach, die sich daraus ergeben, und lassen Sie uns wissen, wenn Sie Fragen haben.