Was ist ein höherwertiger Typ in Scala?

Im Internet finden Sie Folgendes:

1. Höher sortierter Typ == Typ Konstruktor?

   class AClass[T]{...} // For example, class List[T]

   Einige sagen, dies sei ein höherwertiger Typ, da er über Typen abstrahiert, die der Definition entsprechen würden.

   Höher sortierte Typen sind Typen, die andere Typen annehmen und einen neuen Typ erstellen

   Diese werden jedoch auch als Typkonstruktor bezeichnet . (Zum Beispiel in Programmieren in Scala ).

2. Höher sortierter Typ == Typkonstruktor, der den Typkonstruktor als Typparameter verwendet?

   In der Zeitung Generika höherer Art können Sie lesen

   ... Typen, die über Typen abstrahieren, die über Typen abstrahieren ('Typen höherer Art') ... "

   was darauf hindeutet

   class XClass[M[T]]{...} // or
   
   trait YTrait[N[_]]{...} // e.g. trait Functor[F[_]]

   ist ein höherwertiger Typ.

Also in diesem Sinne ist es schwierig , zu unterscheiden zwischen Typkonstruktor , höherer kinded Art und Typkonstruktor der Typkonstruktoren als Typ - Parameter nimmt daher die Frage oben.

Lassen Sie mich etwas von dieser Verwirrung wettmachen, indem ich mit einer gewissen Begriffsklärung einspringe. Ich verwende gerne die Analogie zur Wertebene, um dies zu erklären, da die Leute eher damit vertraut sind.

Ein Typkonstruktor ist ein Typ, den Sie auf Typargumente anwenden können, um einen Typ zu "konstruieren".

Ein Wertekonstruktor ist ein Wert, den Sie auf Wertargumente anwenden können, um einen Wert zu "konstruieren".

Wertekonstruktoren werden normalerweise als "Funktionen" oder "Methoden" bezeichnet. Diese "Konstruktoren" werden auch als "polymorph" (weil sie verwendet werden können, um "Zeug" unterschiedlicher "Form" zu konstruieren) oder "Abstraktionen" (da sie über das abstrahieren, was zwischen verschiedenen polymorphen Instanziierungen variiert) bezeichnet.

Im Kontext von Abstraktion / Polymorphismus bezieht sich erste Ordnung auf die "einmalige Verwendung" von Abstraktion: Sie abstrahieren einmal über einen Typ, aber dieser Typ selbst kann nicht über irgendetwas abstrahieren. Java 5-Generika sind erster Ordnung.

Die Interpretation der obigen Charakterisierungen von Abstraktionen erster Ordnung ist:

Ein Typkonstruktor ist ein Typ, den Sie auf geeignete Typargumente anwenden können, um einen geeigneten Typ zu "konstruieren".

Ein Wertekonstruktor ist ein Wert, den Sie auf geeignete Wertargumente anwenden können, um einen geeigneten Wert zu "konstruieren".

Um zu betonen, dass es sich nicht um eine Abstraktion handelt (ich denke, Sie könnten dies als "nullter Ordnung" bezeichnen, aber ich habe nicht gesehen, dass dies irgendwo verwendet wird), wie zum Beispiel den Wert 1oder den Typ String, sagen wir normalerweise, dass etwas ein "richtiger" Wert oder Typ ist.

Ein geeigneter Wert ist "sofort verwendbar" in dem Sinne, dass er nicht auf Argumente wartet (er abstrahiert nicht über sie). Stellen Sie sich diese als Werte vor, die Sie leicht drucken / überprüfen können (das Serialisieren einer Funktion ist Betrug!).

Ein richtiger Typ ist ein Typ, der Werte klassifiziert (einschließlich Wertekonstruktoren). Typkonstruktoren klassifizieren keine Werte (sie müssen zuerst auf die richtigen Typargumente angewendet werden, um einen richtigen Typ zu erhalten). Um einen Typ zu instanziieren, ist es notwendig (aber nicht ausreichend), dass es sich um einen richtigen Typ handelt. (Es kann sich um eine abstrakte Klasse handeln oder um eine Klasse, auf die Sie keinen Zugriff haben.)

"Höhere Ordnung" ist einfach ein Oberbegriff, der die wiederholte Verwendung von Polymorphismus / Abstraktion bedeutet. Dies gilt auch für polymorphe Typen und Werte. Konkret abstrahiert eine Abstraktion höherer Ordnung über etwas, das über etwas abstrahiert. Für Typen ist der Begriff "höherwertig" eine Spezialversion der allgemeineren "übergeordneten Ordnung".

Somit wird die übergeordnete Version unserer Charakterisierung:

Ein Typkonstruktor ist ein Typ, den Sie auf Typargumente (richtige Typen oder Typkonstruktoren) anwenden können, um einen richtigen Typ (Konstruktor) zu "konstruieren".

Ein Wertekonstruktor ist ein Wert, den Sie auf Wertargumente (Eigenwerte oder Wertekonstruktoren) anwenden können, um einen Eigenwert (Konstruktor) zu "konstruieren".

"Höhere Ordnung" bedeutet also einfach, dass Sie es wirklich meinen, wenn Sie "über X abstrahieren" sagen! Das X, über das abstrahiert wird, verliert nicht seine eigenen "Abstraktionsrechte": Es kann alles abstrahieren, was es will. (Übrigens verwende ich hier das Verb "abstrakt", um zu bedeuten: etwas wegzulassen, das für die Definition eines Wertes oder Typs nicht wesentlich ist, damit es vom Benutzer der Abstraktion als Argument variiert / bereitgestellt werden kann .)

Hier sind einige Beispiele (inspiriert von Lutz 'Fragen per E-Mail) für richtige Werte und Typen erster und höherer Ordnung:

                   proper    first-order           higher-order

values             10        (x: Int) => x         (f: (Int => Int)) => f(10)
types (classes)    String    List                  Functor
types              String    ({type λ[x] = x})#λ   ({type λ[F[x]] = F[String]})#λ

Wo die verwendeten Klassen definiert wurden als:

class String
class List[T]
class Functor[F[_]]

Um die Indirektion durch das Definieren von Klassen zu vermeiden, müssen Sie anonyme Typfunktionen ausdrücken, die in Scala nicht direkt ausgedrückt werden können. Sie können jedoch Strukturtypen ohne zu großen syntaktischen Aufwand verwenden (der #λStil ist auf https://stackoverflow.com zurückzuführen / users / 160378 / retronym afaik):

In einer hypothetischen zukünftigen Version von Scala, die anonyme Typfunktionen unterstützt, können Sie diese letzte Zeile aus den Beispielen auf Folgendes verkürzen:

types (informally) String    [x] => x              [F[x]] => F[String]) // I repeat, this is not valid Scala, and might never be

(Persönlich bedauere ich, dass ich jemals über "höherwertige Typen" gesprochen habe, sie sind schließlich nur Typen! Wenn Sie unbedingt unterscheiden müssen, schlage ich vor, Dinge wie "Typkonstruktorparameter", "Typkonstruktormitglied" zu sagen. oder "Typkonstruktor-Alias", um zu betonen, dass es sich nicht nur um richtige Typen handelt.)

ps: Um die Sache noch weiter zu verkomplizieren, ist "polymorph" auf andere Weise mehrdeutig, da ein polymorpher Typ manchmal einen universell quantifizierten Typ bedeutet, z. B. Forall T, T => Teinen geeigneten Typ, da er polymorphe Werte klassifiziert (in Scala kann dieser Wert sein geschrieben als Strukturtyp {def apply[T](x: T): T = x})

(Diese Antwort ist ein Versuch, die Antwort von Adriaan Moors mit einigen grafischen und historischen Informationen zu dekorieren.)

Höher sortierte Typen sind seit 2.5 Teil von Scala.

• Zuvor erlaubte Scala als Java bisher nicht, den Typkonstruktor ("Generika" in Java) als Typparameter für einen Typkonstruktor zu verwenden. z.B

   trait Monad [M[_]]

  war nicht möglich.

  In Scala 2.5 wurde das Typensystem um die Möglichkeit erweitert, Typen auf einer höheren Ebene zu klassifizieren (bekannt als Typkonstruktor-Polymorphismus ). Diese Klassifikationen werden als Arten bezeichnet.

  (Bild von Generika höherer Art abgeleitet )

  Die Konsequenz ist, dass der Typkonstruktor (z. B. List) genauso wie andere Typen in der Position der Typparameter von Typkonstruktoren verwendet werden kann und daher seit Scala 2.5 zu erstklassigen Typen wird. (Ähnlich wie Funktionen, die in Scala erstklassige Werte sind).

  Im Kontext eines Typsystems, das höhere Arten unterstützt, können wir geeignete Typen , Typen wie Intoder List[Int]von Typen erster Ordnung wie Listund Typen höherer Art wie Functoroder Monad(Typen, die über Typen abstrahieren, die über Typen abstrahieren) unterscheiden.

  Das Typsystem von Java auf der anderen Seite unterstützt keine Arten und hat daher keine Typen einer "höheren Art".

  Dies muss also vor dem Hintergrund des unterstützenden Typsystems gesehen werden.

• Im Fall von Scala sehen Sie häufig Beispiele für einen Typkonstruktor wie

   trait Iterable[A, Container[_]]

  mit der Überschrift "Höher sortierte Typen", zB in Scala für generische Programmierer, Abschnitt 4.3

  Dies ist manchmal irreführend, weil viele Containerals höherwertiger Typ bezeichnen und nicht Iterable, aber was genauer ist, ist:

  die Verwendung Containereines Typkonstruktorparameters eines Typs höherer Art (höherer Ordnung) als Typ hier Iterable.

Die Art von gewöhnlichen Typen wie Intund Char, deren Instanzen Werte sind, ist *. Die Art von unären Typkonstruktoren wie Maybeist * -> *; Konstruktoren vom binären Typ wie Eitherhaben ( Curry- ) Art * -> * -> *und so weiter. Sie können Typen wie Maybeund anzeigenEither als Funktionen auf : Sie nehmen einen oder mehrere Typen an und geben einen Typ zurück.

Eine Funktion ist höherer Ordnung, wenn sie eine Ordnung größer als 1 hat, wobei die Reihenfolge (informell) die Verschachtelungstiefe der Funktionspfeile links ist:

• Bestellung 0: 1 :: Int
• Bestellung 1: chr :: Int -> Char
• Bestellung 2 : fix :: (a -> a) -> a,map :: (a -> b) -> [a] -> [b]
• Bestellung 3: ((A -> B) -> C) -> D
• Bestellung 4: (((A -> B) -> C) -> D) -> E

Kurz gesagt, ein Typ höherer Ordnung ist nur eine Funktion höherer Ordnung auf Typebene .

• Bestellung 0: Int :: *
• Bestellung 1: Maybe :: * -> *
• Reihenfolge 2: Functor :: (* -> *) -> Constraint- höherwertig: Konvertiert unäre Typkonstruktoren in Typklasseneinschränkungen

Ich würde sagen: Ein höherwertiger Typ abstrahiert über einen Typkonstruktor . ZB überlegen

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

Hier Functorist ein "höherwertiger Typ" (wie er im "Generics of a Higher Kind" -Papier verwendet wird ). Es ist kein konkreter Konstruktor vom Typ "erster Ordnung" List(der nur über die richtigen Typen abstrahiert). Es abstrahiert über alle unären Konstruktoren ("erster Ordnung") (wie mit bezeichnet F[_]).

Oder List<T>anders ausgedrückt: In Java haben wir eindeutig Typkonstruktoren (z. B. ), aber wir haben keine "höher sortierten Typen", weil wir nicht über sie abstrahieren können (z. B. können wir Functordie oben definierte Schnittstelle nicht schreiben - zumindest nicht direkt ).

Der Begriff "Polymorphismus höherer Ordnung (Typkonstruktor)" wird verwendet, um Systeme zu beschreiben, die "Typen höherer Ordnung" unterstützen.

Scala REPL bietet :kindBefehl, der

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

Zum Beispiel,

scala> trait Foo[A]
trait Foo

scala> trait Bar[F[_]]
trait Bar

scala> :kind -v Foo
Foo's kind is F[A]
* -> *
This is a type constructor: a 1st-order-kinded type.

scala> :kind -v Foo[Int]
Foo[Int]'s kind is A
*
This is a proper type.

scala> :kind -v Bar
Bar's kind is X[F[A]]
(* -> *) -> *
This is a type constructor that takes type constructor(s): a higher-kinded type.

scala> :kind -v Bar[Foo]
Bar[Foo]'s kind is A
*
This is a proper type.

Das :helpenthält klare Definitionen, daher denke ich, dass es sich lohnt, es hier in seiner Gesamtheit zu veröffentlichen (Scala 2.13.2).

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

    -v      Displays verbose info.

"Kind" is a word used to classify types and type constructors
according to their level of abstractness.

Concrete, fully specified types such as `Int` and `Option[Int]`
are called "proper types" and denoted as `A` using Scala
notation, or with the `*` symbol.

    scala> :kind Option[Int]
    Option[Int]'s kind is A

In the above, `Option` is an example of a first-order type
constructor, which is denoted as `F[A]` using Scala notation, or
* -> * using the star notation. `:kind` also includes variance
information in its output, so if we ask for the kind of `Option`,
we actually see `F[+A]`:

    scala> :k -v Option
    Option's kind is F[+A]
    * -(+)-> *
    This is a type constructor: a 1st-order-kinded type.

When you have more complicated types, `:kind` can be used to find
out what you need to pass in.

    scala> trait ~>[-F1[_], +F2[_]] {}
    scala> :kind ~>
    ~>'s kind is X[-F1[A1],+F2[A2]]

This shows that `~>` accepts something of `F[A]` kind, such as
`List` or `Vector`. It's an example of a type constructor that
abstracts over type constructors, also known as a higher-order
type constructor or a higher-kinded type.