Nun, schwaches vs. starkes Tippen ist ziemlich vage definiert. Da der allgemeine Gebrauch von "starker Typisierung" am ehesten darin besteht, Dinge zu bezeichnen, die das Gießen von Typen erschweren, bleibt nichts anderes übrig, um noch stärkere Typensysteme zu beschreiben. Es ist wie zu sagen, wenn Sie weniger als 30 Pfund tragen können, sind Sie schwach, und jeder, der mehr heben kann, ist in der gleichen Kategorie von "stark" - eine irreführende Unterscheidung.
Also bevorzuge ich die Definition:
- Schwach getypte Systeme verwenden Typen, um Sie daran zu hindern, bestimmte Dinge (wie Fehler) zu tun.
- Stark typisierte Systeme verwenden Typen, um Dinge für Sie zu erledigen
Was meine ich damit, Dinge für dich zu tun? Nun, lassen Sie uns das Schreiben einer Bildkonvertierungs-API im Servant-Framework untersuchen (in Haskell, aber Sie müssen es nicht wirklich wissen, um mitzumachen, Sie werden sehen ...)
{-# LANGUAGE
TypeOperators,
DataKinds
#-}
import Codec.Picture
import Data.Proxy
import Network.Wai.Handler.Warp (run)
import Servant
import Servant.JuicyPixels
main :: IO ()
main = run 8001 conversion
Dies bedeutet, dass wir einige Module, einschließlich des Servant-Pakets und des JuicyPixels-Plugins für Servant, benötigen und dass der Haupteinstiegspunkt des Programms darin besteht, die Konvertierungsfunktion auf Port 8001 als Server über das Warp-Backend auszuführen. Ignoriere das Sprachbit.
conversion :: Application
conversion = serve (Proxy :: Proxy ConversionApi) handler
Dies bedeutet, dass die Konvertierungsfunktion ein Server ist, auf dem die API dem Typ 'ConversionApi' entsprechen muss und die Anforderungen von der Funktion verarbeitet werden handler
type ConversionApi
= ReqBody '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE] DynamicImage
:> Post '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE] DynamicImage
Dies gibt den ConvesionApiTyp an. Es heißt, wir sollten eingehende Inhaltstypen akzeptieren, die in der Liste '[BMP, GIF, JPEG 50, PNG, TIFF, RADIANCE] angegeben sind, und sie als DynamicImage behandeln und ein DynamicImage zurückgeben, das in denselben Inhaltsbereich konvertiert wurde Typen. Machen Sie sich keine Gedanken darüber, was:> bedeutet, stellen Sie es sich vorerst als glückliche Magie vor.
Aufgrund meiner bevorzugten Definition kann ein schwach typisiertes System nun Folgendes sicherstellen:
- Sie geben nicht den falschen ausgehenden Inhaltstyp zurück
- Sie analysieren die eingehende Anforderung nicht als den falschen Inhaltstyp
- Wenn unser Server komplizierter wäre, könnten wir keine ungültigen URIs erstellen, aber wir geben keine HTML-Seiten zurück, die Links enthalten (und der Typ stellt sicher, dass dies nicht möglich ist!).
- Ein wirklich ehrgeiziges schwaches Typisierungssystem könnte sogar prüfen, ob wir alle eingehenden und ausgehenden Inhaltstypen vollständig verarbeiten, sodass der Typ auch als Spezifikationsdokument und nicht nur als Einschränkung fungieren kann.
Alle hohen Ziele, aber nicht genug, um sich als stark typisiertes System zu qualifizieren, wenn man die obige Definition zugrunde legt. Und jetzt müssen wir uns dem schwierigen Teil des eigentlichen Schreibens von Code zuwenden, der dieser Spezifikation folgt. In einem wirklich starken Typensystem schreiben wir:
handler = return
Und dann sind wir fertig. Das war's, es gibt keinen Code mehr zum Schreiben . Dies ist ein voll funktionsfähiger Webserver (Modulo alle Tippfehler, die ich verpasst habe). Der Typ hat dem Compiler alles mitgeteilt, was er zum Erstellen unseres Webservers aus den von uns definierten und importierten Typen und Paketen (Module technisch gesehen) benötigt.
Wie lernen Sie dies auf der Hauptanwendungsskala? Nun, es unterscheidet sich nicht wesentlich von der Verwendung in kleineren Anwendungen. Absolute Typen interessieren sich nicht dafür, wie viel Code in Bezug auf sie geschrieben ist.
Die Typprüfung zur Laufzeit ist etwas, das Sie wahrscheinlich vermeiden möchten, da dies einen großen Teil des Nutzens einspart und es den Typen ermöglicht, die Arbeit mit Ihrem Projekt komplizierter zu gestalten, anstatt die Dinge durch Typen zu vereinfachen.
Daher ist es meist nur eine Frage der Übung, Dinge mit Typen zu modellieren. Die beiden Hauptmethoden zum Modellieren von Dingen (oder zum Erstellen von Dingen im Allgemeinen) sind Bottom-up und Top-down. Top-down beginnt mit der höchsten Ebene von Operationen, und wenn Sie das Modell erstellen, haben Sie Teile, bei denen Sie die Modellierung auf einen späteren Zeitpunkt verschieben. Bottom-up-Modellierung bedeutet, dass Sie mit Basisoperationen beginnen, genau wie Sie mit Basisfunktionen beginnen, und dann immer größere Modelle erstellen, bis Sie die Operation des Projekts vollständig erfasst haben. Bottom-up ist konkreter und lässt sich wahrscheinlich schneller erstellen, aber Top-down kann Ihre Modelle auf niedrigerer Ebene besser darüber informieren, wie sie sich tatsächlich verhalten müssen.
Typen beziehen sich im wahrsten Sinne des Wortes auf Mathematik. Es gibt also keine Obergrenze dafür, wie kompliziert sie werden können, oder einen Punkt, an dem man "fertig" sein kann, um etwas über sie zu lernen. Nahezu alle Ressourcen außerhalb von Universitätskursen auf höherer Ebene beziehen sich auf die Funktionsweise von Typen in einer bestimmten Sprache. Sie müssen sich also auch dafür entscheiden.
So gut ich kann, können Typen wie folgt geschichtet werden:
- Sehr schwach getippt, Dinge wie JavaScript, in denen [] + {} definiert ist
- Schwach getippt wie Python, wo Sie nicht [] + {} tun können, aber das wird nicht überprüft, bis Sie es versuchen
- Schwach wie C oder Java getippt, wo Sie [] + {} nicht tun können, dies jedoch beim Kompilieren überprüft wird, verfügen Sie jedoch nicht über die erweiterten Typfunktionen
- Spreizung der Grenze zwischen schwach und stark typisiert, z. B. Metaprogrammierung von C ++ - Vorlagen und einfacherem Haskell-Code, bei dem Typen nur Eigenschaften erzwingen.
- Wie bei komplizierteren Haskell-Programmen, bei denen Typen Dinge tun, wie oben gezeigt
- Die sehr stark typisierten, wie Agda oder Idris, bei denen Typen und Werte interagieren und sich gegenseitig einschränken können. Dies ist so stark wie Typsysteme, und das Programmieren darin ist dasselbe, als würden Sie mathematische Beweise darüber schreiben, was Ihr Programm tut. Hinweis: Bei der Codierung in Agda werden mathematische Beweise nicht buchstäblich geschrieben, Typen sind mathematische Theorien, und Funktionen mit diesen Typen sind konstruktive Beispiele, die diese Theorien beweisen.
Je weiter unten auf dieser Liste Sie sich befinden, desto mehr können Typen für Sie tun, aber ganz unten steigen Sie in die Stratosphäre auf und die Luft wird etwas dünn - das Paket-Ökosystem ist viel kleiner und Sie ' Ich muss mehr Dinge selbst schreiben, als eine relevante Bibliothek gefunden zu haben. Die Eintrittsbarriere steigt auch mit dem Abstieg, da Sie das Typensystem so gut verstehen müssen, dass Sie umfangreiche Programme schreiben können.