Was bedeuten "Reify" und "Reification" im Kontext der (funktionalen?) Programmierung?

Ich habe diesen Begriff viel in Blogs über Haskell und funktionale Programmierung gelesen (insbesondere in Sigfpes Blog ), aber ich habe keine Ahnung, was das bedeutet. Ich komme davon, es die meiste Zeit nicht zu wissen, aber ich hätte die Texte wahrscheinlich viel besser verstanden, wenn ich es gewusst hätte. Google hat mir nicht geholfen. Ich verliere mich in den technischen Dingen.

Auch die nichttechnische Bedeutung der Welt ("das Abstrakte konkretisieren") hilft mir nicht zu verstehen, was es praktisch bedeutet, etwas im Code zu reifizieren.

Ich bin ein bisschen langsam mit Informatikkonzepten, also wären praktische Beispiele mit Code schön. : P.

Also habe ich darüber nachgelesen, und es ist ziemlich genau das, was es bedeutet: ein abstraktes Konzept zu nehmen und es konkret zu machen. Oder es gibt einen Proxy, der das abstrakte Konzept darstellt. In Lisp wird beispielsweise das Konzept der Prozedurabstraktion und -anwendung geändert, wenn Sie Lambdas verwenden.

Die Reifizierung an sich ist ein weit gefasstes Konzept und nicht nur auf funktionale Programmiersprachen anwendbar.

In Java gibt es beispielsweise Typen, die zur Laufzeit verfügbar sind. Dies sind reifizierbare Typen. Das heißt, es gibt eine konkrete Darstellung des abstrakten Konzepts des Typs zur Laufzeit. Im Gegensatz dazu gibt es nicht reifizierbare Typen. Dies zeigt sich insbesondere bei der Verwendung von Generika in Java. In Java unterliegen Generika einer Typlöschung, sodass generische Typinformationen zur Laufzeit nicht verfügbar sind (es sei denn, der parametrisierte Typ verwendet unbegrenzte Platzhalter).

Ein anderes Beispiel ist, wenn Sie versuchen, ein Konzept zu modellieren. Angenommen, Sie haben eine GroupKlasse und eine UserKlasse. Nun gibt es bestimmte abstrakte Konzepte, die die Beziehung zwischen den beiden beschreiben. Zum Beispiel das abstrakte Konzept eines UserWesens, das Mitglied eines Group. Um diese Beziehung konkret zu machen, würden Sie eine Methode mit dem Namen schreiben isMemberOf, ob Usera Mitglied von a ist Group. Also , was haben Sie hier gemacht ist , dass Sie verdinglicht das (real / expliziten / Beton) abstrakte Konzept der Gruppenmitgliedschaft.

Ein weiteres gutes Beispiel ist eine Datenbank, in der Sie Eltern-Kind-Beziehungen zwischen Objekten haben. Sie können diese Beziehung im abstrakten Konzept eines Baumes beschreiben. Angenommen, Sie haben eine Funktion / Methode, die diese Daten aus der Datenbank entnimmt und ein tatsächliches Tree Objekt erstellt. Was Sie jetzt getan haben , ist verdinglicht das abstrakte Konzept der Eltern-Kind - baumartige Beziehung zu einem tatsächlichen Tree Objekt.

Zurück zu den funktionalen Sprachen im Allgemeinen: Das vielleicht beste Beispiel für die Verdinglichung ist die Erstellung der Programmiersprache Lisp. Lisp war ein völlig abstraktes und theoretisches Konstrukt (im Grunde nur eine mathematische Notation für Computersprachen). Dies blieb so, bis die evalFunktion von Lisp tatsächlich von Steve Russel auf einer IBM 704 implementiert wurde:

Nach dem, was Paul Graham in Hackers & Painters berichtet hat, p. McCarthy sagte: "Steve Russell sagte, schau, warum programmiere ich diese Bewertung nicht ... und ich sagte zu ihm, ho, ho, du verwechselst Theorie mit Praxis, diese Bewertung ist zum Lesen gedacht, nicht zum Lesen." Aber er ging voran und tat es. Das heißt, er kompilierte die Auswertung in meinem Artikel in IBM 704-Maschinencode, um Fehler zu beheben, und bewarb dies dann als Lisp-Interpreter, was es sicherlich war. Also hatte Lisp es zu diesem Zeitpunkt getan im Wesentlichen die Form, die es heute hat ... "

So Lisp wurde verdinglicht von einem abstrakten Begriff, in eine tatsächliche Programmiersprache.  

Verdinglichung

Reifikation ist eine Form der Instanziierung. Wenn Sie ein Konzept neu definieren, nehmen Sie etwas Abstraktes und konkretisieren es genau wie die von Ihnen angegebene Wörterbuchdefinition.

Sie können einen Typ als Begriff in einem abstrakten Syntaxbaum möglicher Typen ändern.

Sie können ein Entwurfsmuster ändern, indem Sie eine allgemeine Implementierung für eine bestimmte Sprache erstellen. Zum Beispiel so etwas wie

template<typename T> class Singleton {
    public:
        static T& Instance() {
            static T me;
            return me;
        }

    protected:
       virtual ~Singleton() {};
       Singleton() {};
}

Überprüft das Singleton-Entwurfsmuster als Vorlage in C ++.

Sie können Hoares Idee von Quicksort in eine Implementierung in der Programmiersprache Ihrer Wahl umwandeln. In diesem Sinne verbringe ich viel Zeit damit, Konzepte aus der Kategorietheorie in Haskell-Code umzuwandeln.

Sie können eine Sprache als Dolmetscher für diese Sprache bestätigen. Larry Walls Vorstellung von Perl, der Sprache, wird als Perl-Interpreter bestätigt.

Die Daten-reify und Vakuumpakete reify Begriffe als Graphen darstellt , wie sie im Speicher mit Sharing strukturiert ist.

Betrachtung

Die Kehrseite der Verdinglichung ist die Reflexion , die etwas Konkretes nimmt und eine Abstraktion erzeugt, normalerweise durch Vergessen einiger Details. Vielleicht möchten Sie dies tun, weil die Abstraktion einfacher ist oder irgendwie die Essenz dessen erfasst, wovon Sie sprechen.

Die Typsystemreflexion in Java, C # usw. verwendet eine konkrete Klasse in einer Programmiersprache und stellt Ihnen die abstrakte Struktur einer Klasse zur Verfügung, sodass Sie auf die Liste der Mitglieder zugreifen können, die Ihre Klassen bereitstellen. Hier nehmen wir den konkreten Begriff eines Typs und generieren daraus einen abstrakten Begriff, der seine Struktur beschreibt, während wir bestimmte Werte verwerfen.

So wie Sie eine Programmiersprache in eine Implementierung umwandeln können, können Sie manchmal in die entgegengesetzte Richtung gehen. Obwohl dies im Allgemeinen als schlechte Idee angesehen wird, können Sie eine Implementierung nehmen und versuchen, eine Sprachspezifikation anhand der gewünschten Eigenschaften ihres Verhaltens widerzuspiegeln. TeX wurde zuerst von Knuth ohne Spezifikation implementiert . Jede Spezifikation von TeX wurde aus der Implementierung von Knuth übernommen.

(Wenn Sie Reflexion formeller als einen vergesslichen Funktor betrachten, der Sie von einer konkreten Domäne zu einer abstrakten Domäne führt, wird die Verdinglichung im Idealfall neben der Reflexion gelassen.)

Das von mir verwaltete Reflection- Paket enthält eine Reify-Methode, die einen Begriff verwendet und einen Typ ergibt, der ihn darstellt, und anschließend eine Reflection-Methode, mit der Sie einen neuen Term generieren können. Hier ist die 'konkrete' Domäne das Typensystem, und die abstrakte Domäne sind Begriffe.

Aus dem Haskell-Wiki :

Etwas zu "reifizieren" bedeutet, etwas Abstraktes zu nehmen und es als materiell zu betrachten. Ein klassisches Beispiel ist die Art und Weise, wie die Alten abstrakte Konzepte (z. B. "Sieg") aufnahmen und sie in Gottheiten verwandelten (z. B. Nike, die griechische Siegesgöttin).

Ein reifizierter Typ ist ein Wert, der einen Typ darstellt. Die Verwendung von reifizierten Typen anstelle von realen Typen bedeutet, dass Sie mit ihnen alle Manipulationen vornehmen können, die Sie mit Werten vornehmen können.

Eine Verwendung, an die ich denken kann (ich bin sicher, es gibt andere!), Ist die Umwandlung einer Klasse in ein Wörterbuch. Nehmen wir die EqKlasse (vergessen wir den /=Operator für den Moment):

class Eq a where
    (==) :: a -> a -> Bool

Wenn wir diese Klasse wiederholen, wird es:

data EqDict a = EqDict (a -> a -> Bool)

die gebaut, inspiziert und so weiter werden können. Bemerkenswert ist auch, dass Sie nur eine EqInstanz pro Typ haben können, aber mehrere EqDictWerte. Die automatische Erstellung von Instanzen (z. B. Gleichheit für Listen erhalten, wenn Sie sie für Elemente haben) funktioniert jedoch nicht. Sie müssen den EqDict [a]Wert selbst konstruieren .

Der Reifizierungsprozess ist so einfach (für diesen Fall):

reify :: Eq a => EqDict a
reify = EqDict (==)

Eine Funktion, die die EqKlasse verwendet, könnte Folgendes transformieren:

-- silly example, doesn't really do anything
findMatches :: Eq a => a -> [a] -> [a]
findMatches x ys = [ y | y <- ys, x == y ]

-- version using EqDict
findMatchesDict :: EqDict a -> a -> [a] -> [a]
findMatchesDict (EqDict f) x ys = [ y | y <- ys, f x y ]

Wenn Sie das EqDict auspacken und nur ein übergeben a -> a -> Bool, erhalten Sie die ..ByFunktionen like Data.List.nubByund friends - ein ähnlicher Trick für Ordführt zu Data.List.sortBy.

Selbst nur im Zusammenhang mit Haskell wird der Begriff sehr weit verbreitet verwendet. Mit dem Reify-Paket von Andy Gill können Sie rekursive Strukturen in explizite Diagramme umwandeln. In Sigpfe's Posting on Continuations wird beschrieben, wie der Begriff "der Rest der Berechnung" in einen Wert umgewandelt wird, den Sie weitergeben können. Vorlage Haskell verfügt über eine Überprüfungsfunktion (die zusammen mit dem TH-Code im Allgemeinen zur Kompilierungszeit ausgeführt wird), die bei Angabe des Namens eines Haskell-Werts verfügbare Informationen darüber zurückgibt (wo deklariert, Typ usw.).

Was haben all diese Fälle gemeinsam? Sie sprechen davon, etwas zu nehmen, über das wir nachdenken und das wir wissen, das wir aber nicht direkt programmgesteuert manipulieren können, und es in einen tatsächlichen erstklassigen Wert umzuwandeln, den wir wie jeden anderen benennen und weitergeben können. Und das ist im Allgemeinen die Absicht, die Menschen vermitteln wollen, wenn sie das Wort verwenden.

Ich weiß, dass es in RDF das Konzept der Verdinglichung gibt. Wie von Tim Bernes-Lee angegeben :

Reifizierung bedeutet in diesem Zusammenhang den Ausdruck von etwas in einer Sprache unter Verwendung der Sprache, so dass es von der Sprache behandelt werden kann.

Ich nehme an, es ist wie Reflexion oder Selbstbeobachtung. Ich hoffe du bekommst hier ein paar gute Antworten!