Einrichtungen zur Erzeugung von Haskell-Typen in Haskell ( „zweiter Ordnung Haskell“)?

Question

Apologies im Voraus, wenn diese Frage ist ein wenig vage. Es ist das Ergebnis einer Wochenende Träumerei.

Mit Haskell wunderbaren Art System, es ist erfreulich herrlich mathematisch (insbesondere algebraische) Struktur als typeclasses auszudrücken. Ich meine, haben nur einen Blick auf numeric-Auftakt ! Aber die Vorteile einer solchen wunderbaren Art Struktur in der Praxis hat schien immer schwierig für mich.

Sie haben einen schönen, Typ-System Art und Weise, dass v1 und v2 auszudrücken sind Elemente eines Vektorraum V und dass w ist ein Element eines Vektorraum W. Der Typ-System können Sie ein Programm das Hinzufügen v1 und v2 schreiben, aber nicht v1 und w. Groß! Aber in der Praxis möchten Sie vielleicht mit potenziell Hunderte von Vektorräumen spielen, und Sie sicherlich nicht wollen, Typen V1, V2, ..., V100 erstellen und diese Instanzen des Vektorraum typeclass erklären! Oder vielleicht haben Sie einige Daten aus der realen Welt zu lesen, was zu Symbolen a, b und c - Sie möchten zum Ausdruck bringen, dass der freie Vektorraum über diese Symbole wirklich ein Vektorraum

Sie sind also stecken, nicht wahr? Um viele der Dinge zu tun, wenn Sie möchten mit Vektorräumen in einer wissenschaftlichen Rechnen Einstellung zu tun, müssen Sie Ihre Typisierung aufgeben durch einen Vektorraum typeclass verzichten und mit Funktionen zu tun Laufzeitkompatibilitätsprüfungen statt. Sollten Sie haben? Sollte es nicht möglich sein, die Tatsache zu nutzen, dass Haskell rein funktional ist, ein Programm zu schreiben, das die Typen alles, was Sie brauchen, und fügt sie in das reale Programm generiert? Gibt es eine solche Technik exist? Mit allen Mitteln darauf hinweisen, wenn ich einfach hier grundlegend etwas mit Blick auf bin (ich bin wahrscheinlich): -)

Edit: Soeben habe ich entdeckt fundeps . Ich werde ein wenig darüber nachdenken, wie sie auf meine Frage beziehen (erleuchten Kommentare in Bezug auf diese geschätzt werden).

Answer 1

Template Haskell ermöglicht diese . Die Wikiseite einige nützliche Links hat; insbesondere Bulat der Tutorials .

Die Deklaration der obersten Ebene Syntax ist diejenige, die Sie wollen. Durch Eingabe:

mkFoo = [d| data Foo = Foo Int |]

erzeugen Sie eine Vorlage Haskell splice (wie eine Kompilierung-Funktion), die eine Erklärung für data Foo = Foo Int schaffen wird nur durch die Linie $(mkFoo) eingefügt wird.

Während dieses kleine Beispiel nicht zu nützlich ist, könnten Sie ein Argument mkFoo zu steuern, wie viele verschiedene Erklärungen liefern Sie möchten. Nun wird ein $(mkFoo 100) 100 neue Datendeklarationen für Sie produzieren. Sie können auch TH verwenden, um Typ-Klasseninstanzen zu erzeugen. Mein adaptiv-Tupel Paket ist ein sehr kleines Projekt, das Template Haskell verwendet etwas ähnliches zu tun.

Ein alternativer Ansatz wäre verwenden Derive , die automatisch ableiten Typ Klasseninstanzen . Dies könnte einfacher sein, wenn Sie nur die Instanzen müssen.

Answer 2

Auch gibt es einige einfache Art-Level-Programmiertechniken in Haskell. Ein kanonisches Beispiel folgt:

-- A family of types for the natural numbers
data Zero
data Succ n

-- A family of vectors parameterized over the naturals (using GADTs extension)
data Vector :: * -> * -> * where
    -- empty is a vector with length zero
    Empty :: Vector Zero a
    -- given a vector of length n and an a, produce a vector of length n+1
    Cons  :: a -> Vector n a -> Vector (Succ n) a

-- A type-level adder for natural numbers (using TypeFamilies extension)
type family Plus n m :: *
type instance Plus Zero n = n
type instance Plus (Succ m) n = Succ (Plus m n)

-- Typesafe concatenation of vectors:
concatV :: Vector n a -> Vector m a -> Vector (Plus n m) a
concatV Empty ys = ys
concatV (Cons x xs) ys = Cons x (concatV xs ys)

Nehmen Sie einen Moment, das zu nehmen. Ich denke, es ist ziemlich magisch ist, dass es funktioniert.

Allerdings Typ-Level-Programmierung in Haskell ist in dem Feature-unheimlichen-Tal - gerade genug, um darauf aufmerksam zu machen, wie viel können Sie nicht tun. Unselbständig typisierte Sprachen wie Agda , Coq und Epigram nehmen diesen Stil an seine Grenzen und volle Leistung.

Template Haskell ist viel mehr wie die üblichen Lisp-Makro Stil der Codegenerierung. Sie schreiben einige Code einen Code zu schreiben, dann Sie „ok Einsatz, das hier generierte Code“ sagen. Im Gegensatz zu der obigen Technik können Sie einen beliebigen computably angegebenen Code schreiben, auf diese Weise, aber Sie nicht die sehr allgemeine Typprüfung erhalten, wie in concatV oben zu sehen ist.

So können Sie ein paar Optionen zu tun, was Sie wollen. Ich denke, metaprogramming ein wirklich interessanter Raum ist, und in mancher Hinsicht noch recht jung. Viel Spaß beim Entdecken. : -)