Die Sprachen Ocaml und Haskell stammen von der ISWIM-Sprache ab, die in dem berühmten Artikel von Peter Lendin "Die nächsten 700 Programmiersprachen" beschrieben wird. Darin der Autor aus der LISP Sprache starten, erstellt eine neue Programmiersprache und insbesondere stellen Schlüsselwörter let
, and
und where
, die in den Sprachen der ML - Familie weit verbreitet sind. Früher oder später hat jeder neugierige Geist, der sich mit funktionaler Programmierung beschäftigt, eine Frage: Warum hat das where
in Haskell weit verbreitete Schlüsselwort in Ocaml keine Wurzeln geschlagen ?
Aus meiner Sicht ist dies hauptsächlich auf die Unterschiede in der Semantik dieser Sprachen zurückzuführen, nämlich auf die imperativ-energetische Natur von Ocaml und die Reinheit-Faulheit der Bewertung in Haskell (die direkt und stark mit den unreinen / reinen Charakteren zusammenhängen dieser Sprachen).
Diese beiden Ausdrücke let
und where
sind von (let ...)
der LISP-Sprache abgeleitet, die zwei Varianten dieser speziellen Form aufweist: (let ...)
und (let* ...)
. Die Variante (let* ...)
unterscheidet sich darin, dass alle Bindungen im Block nacheinander auftreten und voneinander abhängen können:
(let* ((x 3)
(y (+ x 2))
(z (+ x y 5)))
(* x z))
In einigen Dialekten des Schemas können Variablendeklarationen vom Interpreter automatisch neu angeordnet werden, sodass es nicht mehr erforderlich ist, sie in der "richtigen" Reihenfolge zu schreiben. Beide Optionen für die Bindung, let ... in
und where
entsprechen diese „fortgeschrittenen“ Option (let* ...)
. Ocaml verwendet jedoch ein Schlüsselwort, um "parallele Bindungen" zu trennen and
, während Haskell sie einfach in einen Block einfügt .
Wenn Sie ausschließlich auf dem Wesen der Dinge anschaut, kann man sehen , dass die Ausdrücke let ... in
und where
in zwei Aspekten unterscheiden: der Ort , wo die Bindung platziert wird, und die Anzahl von Ausdrücken in dem Block.
Verbindliche Namen vor und nach Gebrauch.
- let ... in
, , where
:
let x = 1 in
x + 1
z = x + 1
where x = 1
, let ... in Ocaml, , , / . ,
let x = Printf.printf "Hello ";
"World!"
in
Printf.printf "%s" x
. top-level Ocaml, , open
let () = ...
, where non-strict Haskell, term/graph reduction. , where
, :
main = putStrLn (x ++ y)
where x = "Hello "
y = "World!"
z = undefined
: x
y
, . z
, - .
x
, y
, z
let ... in
, Haskell, - z
, . , do
, let
.
shadowing
C let ... in
, Ocaml, Haskell, . where
- :
let x = 1 in
let y = 1 in
x + y
z = x + y
where x = 1
y = 1
, , , , , , "shadowing". Ocaml shadowing , :
let x = 1 in
let x = x * 10 in
x * x
, , :
x := 1;
x := x * 10;
return x*x;
Haskell, where
, "", shadowing , . shadowing , top-level , - non-strict . , Haskell
x = x + 1
.
shadowing Ocaml Haskell , Ocaml , Ocaml Haskell (backpack , - t
M
Ocaml ).
Ocaml , -, (.mli) (.ml). , , -, , top-level , . - , Ocaml top-level , . , let ... in (., report_constructor_mismatch https://github.com/ocaml/ocaml/blob/trunk/typing/includecore.ml#L212 )
Haskell , . , , - , , top-level . , where shadowing.
, , - Clean.
, , where
, let ... in
"-", , . , , , Haskell , Ocaml .
, Ocaml, Stdlib
where , , , . , List.mapi
List.rev_map
. , , Ocaml , , - graph rewriting . , Ocaml where
, , Haskell let ... in
.
So schaffen die Sprachen Ocaml und Haskell wie gute technische Arbeiten eine Synergie aus Syntax und Semantik. Bindungsrichtlinien let
und where
spielen eine Rolle, wobei der Schwerpunkt auf dem linearen psevdoimperativnuyu und dem "faulen" (Graph Reduction) Leistungsmodell liegt. Sie funktionieren auch gut mit Ihrem bevorzugten Schreibstil für Anwendungen und dem zugehörigen Modulsystem.