Fehlercodes
Jeder Fehler, den der Hilde-Compiler meldet, trägt einen Code wie H4012. Der Code bezeichnet eine Stelle im Compiler; er bleibt gleich, wenn sich der Wortlaut einer Meldung ändert, und wird nie an eine andere Meldung vergeben. Die erste Ziffer nennt die Art: 0 Syntax, 1 Kommandozeile und Pakete, 2 Deklarationen, 3 Typen, 4 Linearität, 5 Einstiegspunkt, 6 allgemein, 7 Vorlagen, 8 SQL, 9 intern. H9999 steht für jeden internen Fehler: einen Fehler im Compiler, nicht im Programm.
Diese Seite wird aus der Quelle des Compilers erzeugt: die Liste der Codes aus den Stellen, die sie auslösen, und zu jedem Code Bedeutung, Meldung und ein Modul, das damit scheitert, aus dem Katalog des Compilers. Jeder Code hat eine eigene Adresse, zum Beispiel /de/errors/#H4012.
Die Quelle dieses Stands löst 570 Codes aus; für 570 davon hat der Katalog einen Eintrag.
In den Beispielen ist rot geschrieben, wo der Fehler liegt.
Abschnitte
- 1. Syntax (13)
- 2. Typen (97)
- 3. Linearität (10)
- 4. Borrowing (21)
- 5. Module (33)
- 6. Anderes (59)
- 7. Templates (120)
- 8. SQL (113)
- 9. Verträge (14)
- 10. Fehlerarten (4)
- 11. Never und Slots (10)
- 12. Ziele (13)
- 13. Pakete (36)
- 14. Sperli (27)
1. Syntax
H0001
Im Quelltext steht ein Zeichen, mit dem kein Token beginnt. Außerhalb von Kommentaren und Strings sind nur Buchstaben, Ziffern, Leerraum und die Symbole der Sprache erlaubt.
Meldung:
Dieses Modul scheitert mit H0001:
module body Example is
function main(): ExitCode is
let total: Int32 := 1 $ 2;
printLn(total);
return ExitSuccess();
end;
end module body.H0003
Ein String-Literal wird mit einem Anführungszeichen geöffnet und nie geschlossen. Der Rest der Datei gehört dann zum String, und die Datei endet mitten darin.
Meldung:
Dieses Modul scheitert mit H0003:
module body Example is
function main(): ExitCode is
printLn("unclosed);
return ExitSuccess();
end;
end module body.H0004
Ein String in dreifachen Anführungszeichen wird geöffnet und nie geschlossen, und die Datei endet mitten darin.
Meldung:
Dieses Modul scheitert mit H0004:
module body Example is
function main(): ExitCode is
printLn("""unclosed);
return ExitSuccess();
end;
end module body.H0005
Die Tokens ergeben kein Programm der Grammatik. Oft steckt ein Ausdruck mit zwei Operatoren ohne Klammern dahinter: Hilde kennt keinen Vorrang von Operatoren.
Meldung:
Dieses Modul scheitert mit H0005:
module body Example is
function main(): ExitCode is
let total: Int32 := 1 +;
printLn(total);
return ExitSuccess();
end;
end module body.H0006
Der Funktionszeigertyp Fn steht ohne Typargumente. Er braucht mindestens eines, den Rückgabetyp, und davor die Typen der Parameter.
Meldung:
Dieses Modul scheitert mit H0006:
module body Example is
function keep(callback: Fn): Unit is
return nil;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H0007
Ein Zeichen-Literal enthält mehr als ein Zeichen. Der Lexer nimmt zwischen den Apostrophen nur ein Zeichen oder ein Escape, also sieht der Parser nie ein längeres Literal; der einzige Weg dahin war ''', das jetzt der Apostroph ist, wie '\''.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H0008
Ein reserviertes Wort steht, wo ein Name hingehört: der Name einer Funktion, eines let, eines var, einer Konstante, die Variable eines for, ein Parameter oder der Name nach as. Wörter wie method, from und body klingen nach guten Namen und sind trotzdem reserviert.
Meldung:
Dieses Modul scheitert mit H0008:
module body Example is
function method(count: Int32): Int32 is
return count;
end;
function main(): ExitCode is
printLn(method(1));
return ExitSuccess();
end;
end module body.H0009
Hilde kennt keinen Vorrang: Ein Operator nimmt zwei atomare Operanden. Nur die assoziativen Operatoren +, *, and und or dürfen eine Kette aus demselben Operator bilden, a + b + c, gelesen von links. Folgt ein anderer Operator auf eine Operation, gehört diese Operation in Klammern. Die Meldung schlägt die Klammern um die Operation vor dem Operator vor.
Meldung:
Dieses Modul scheitert mit H0009:
module body Example is
function main(): ExitCode is
let total: Int32 := 1 + 2 * 3;
printLn(total);
return ExitSuccess();
end;
end module body.H0010
Ein Index steht hinter einem Namen. Das Ergebnis eines Aufrufs wird zuerst an einen Namen gebunden, und der Name wird indiziert.
Meldung:
Dieses Modul scheitert mit H0010:
module body Example is
function digits(): Span[Nat8, Static] is
return "0123";
end;
function main(): ExitCode is
let first: Nat8 := digits()[0];
printLn(first);
return ExitSuccess();
end;
end module body.H0011
Ausleihen lässt sich nur eine Variable. Ein Literal wird zuerst an einen Namen gebunden, und der Name wird ausgeliehen.
Meldung:
Dieses Modul scheitert mit H0011:
module body Example is
generic [R: Region]
function twice(value: &[Int32, R]): Int32 is
return !value * 2;
end;
function main(): ExitCode is
printLn(twice(&21));
return ExitSuccess();
end;
end module body.H0012
Ein Feld steht hinter einem Namen. Das Ergebnis eines Aufrufs wird zuerst an einen Namen gebunden, und dann wird das Feld des Namens gelesen.
Meldung:
Dieses Modul scheitert mit H0012:
module body Example is
record Point: Free is
x: Int32;
y: Int32;
end;
function origin(): Point is
return Point(x => 3, y => 4);
end;
function main(): ExitCode is
let x: Int32 := origin().x;
printLn(x);
return ExitSuccess();
end;
end module body.H6018
In einem String-Literal verbindet ein Backslash mit folgendem Leerraum zwei Teile des Strings, und der Leerraum muss mit einem zweiten Backslash enden. Hier folgt auf den Leerraum etwas anderes.
Meldung:
Dieses Modul scheitert mit H6018:
module body Example is
function main(): ExitCode is
printLn("one \ two");
return ExitSuccess();
end;
end module body.H6058
Das Escape \u{X} schreibt den Codepunkt X als UTF-8. X sind eine bis sechs Hexadezimalziffern, höchstens 10FFFF, und kein Surrogat, D800 bis DFFF.
Meldung:
Dieses Modul scheitert mit H6058:
module body Example is
function main(): ExitCode is
printLn("\u{110000}");
return ExitSuccess();
end;
end module body.2. Typen
H2020
Eine Instanz nennt etwas, das keine Typklasse ist.
Meldung:
Dieses Modul scheitert mit H2020:
module body Example is
record Point: Free is
x: Int32;
end;
instance Point(Int32) is
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2021
Eine Instanz definiert eine Methode, die ihre Typklasse nicht deklariert.
Meldung:
Dieses Modul scheitert mit H2021:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
instance Describe(Int32) is
method describe(value: Int32): Int32 is
return value;
end;
method explain(value: Int32): Int32 is
return value;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2022
Eine Instanz lässt eine Methode ihrer Typklasse aus. Die Meldung nennt die fehlenden Methoden.
Meldung:
Dieses Modul scheitert mit H2022:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
method explain(value: T): Int32;
end;
instance Describe(Int32) is
method describe(value: Int32): Int32 is
return value;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2023
Der Parameter einer Typklasse ist im Universum Region deklariert. Eine Region ist kein Typ, eine Typklasse kann sich also nicht auf Regionen beziehen.
Meldung:
Dieses Modul scheitert mit H2023:
module body Example is
typeclass Measure(R: Region) is
method measure(value: Int32): Int32;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2024
Ein Record oder eine Union ist im Universum Region deklariert. Nur Typparameter können für Regionen stehen; ein deklarierter Typ gehört zu Free, Linear oder Type.
Meldung:
Dieses Modul scheitert mit H2024:
module body Example is
record Point: Region is
x: Int32;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2025
Eine Instanz nennt eine Typklasse, die im Modul nicht deklariert und nicht importiert ist.
Meldung:
Dieses Modul scheitert mit H2025:
module body Example is
instance Describe(Int32) is
method describe(value: Int32): Int32 is
return value;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2026
Ein Typparameter einer generischen Funktion kommt weder in ihren Parametern noch im Rückgabetyp vor; kein Aufruf könnte also festlegen, wofür er steht.
Meldung:
Dieses Modul scheitert mit H2026:
module body Example is
generic [T: Free]
function answer(): Int32 is
return 42;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2031
Eine Funktion oder Methode endet ohne return. Auch eine Funktion, die nichts zurückgibt, endet mit return nil. Jeder Pfad zählt: ein Pfad endet mit return, raise, dem Aufruf einer Funktion, die Never zurückgibt, wie abort, oder einem while, dessen Bedingung true ist. Ein if ohne else, das nur im then-Zweig zurückkehrt, lässt einen Pfad offen.
Meldung:
Dieses Modul scheitert mit H2031:
module body Example is
function show(n: Int32): Unit is
printLn(n);
end;
function main(): ExitCode is
show(1);
return ExitSuccess();
end;
end module body.H2032
Das Argument einer generischen Instanz verwendet denselben Typparameter zweimal. Jeder Typparameter darf darin nur einmal vorkommen.
Meldung:
Dieses Modul scheitert mit H2032:
module body Example is
record Pair[A: Free, B: Free]: Free is
left: A;
right: B;
end;
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
generic [U: Free]
instance Describe(Pair[U, U]) is
method describe(value: Pair[U, U]): Int32 is
return 2;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2033
Eine generische Instanz deklariert mehr Typparameter, als ihr Argument verwendet. Typparameter und die im Argument verwendeten Variablen müssen gleich viele sein.
Meldung:
Dieses Modul scheitert mit H2033:
module body Example is
record Box[A: Free]: Free is
content: A;
end;
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
generic [U: Free, V: Free]
instance Describe(Box[U]) is
method describe(value: Box[U]): Int32 is
return 1;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2034
Das Argument einer Instanz ist ein bloßer Typparameter. Eine Instanz gilt einem benannten Typ, dessen Argumente Typparameter sein dürfen.
Meldung:
Dieses Modul scheitert mit H2034:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
generic [U: Free]
instance Describe(U) is
method describe(value: U): Int32 is
return 1;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2035
Das Argument einer generischen Instanz mischt Typparameter mit konkreten Typen. Es verwendet entweder nur Typparameter oder gar keine.
Meldung:
Dieses Modul scheitert mit H2035:
module body Example is
record Pair[A: Free, B: Free]: Free is
left: A;
right: B;
end;
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
generic [U: Free]
instance Describe(Pair[U, Int32]) is
method describe(value: Pair[U, Int32]): Int32 is
return 2;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2037
Ein Typparameter einer generischen Instanz heißt wie der Parameter ihrer Typklasse. Die beiden müssen verschieden heißen.
Meldung:
Dieses Modul scheitert mit H2037:
module body Example is
record Box[A: Free]: Free is
content: A;
end;
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
generic [T: Free]
instance Describe(Box[T]) is
method describe(value: Box[T]): Int32 is
return 1;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3003
Ein Typparameter einer generischen Funktion müsste im selben Aufruf für zwei verschiedene Typen stehen.
Meldung:
Dieses Modul scheitert mit H3003:
module body Example is
generic [T: Free]
function first(a: T, b: T): T is
return a;
end;
function main(): ExitCode is
let n: Int32 := 1;
let flag: Bool := true;
printLn(first(n, flag));
return ExitSuccess();
end;
end module body.H3004
Ein Typargument liegt in einem Universum, das sein Typparameter nicht zulässt, etwa ein Linear-Typ, wo der Parameter Free verlangt.
Meldung:
Dieses Modul scheitert mit H3004:
module body Example is
record Ticket: Linear is
number: Int32;
end;
generic [T: Free]
function keep(value: T): T is
return value;
end;
function main(): ExitCode is
let ticket: Ticket := keep(Ticket(number => 1));
let { number: Int32 } := ticket;
printLn(number);
return ExitSuccess();
end;
end module body.H3007
Eine Instanz gilt einem Typ, dessen Universum die Typklasse nicht zulässt, etwa einem Linear-Typ für eine Klasse über Free-Typen.
Meldung:
Dieses Modul scheitert mit H3007:
module body Example is
record Ticket: Linear is
number: Int32;
end;
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
instance Describe(Ticket) is
method describe(value: Ticket): Int32 is
let { number: Int32 } := value;
return number;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3008
Die beiden Operanden eines Rechenoperators haben verschiedene Typen. Hilde wandelt nichts stillschweigend um; ein Operand wird vorher umgewandelt.
Meldung:
Dieses Modul scheitert mit H3008:
module body Example is
function main(): ExitCode is
let small: Int32 := 1;
let large: Int64 := 2;
printLn(small + large);
return ExitSuccess();
end;
end module body.H3009
Ein Operand eines Rechenoperators ist keine Zahl.
Meldung:
Dieses Modul scheitert mit H3009:
module body Example is
function main(): ExitCode is
let flag: Bool := true;
printLn(flag + flag);
return ExitSuccess();
end;
end module body.H3010
Ein Wert eines vorzeichenlosen Typs wird negiert. Nat8 bis Nat64, Index und ByteSize haben keine negativen Werte.
Meldung:
Dieses Modul scheitert mit H3010:
module body Example is
function main(): ExitCode is
let n: Nat8 := 5;
printLn(-n);
return ExitSuccess();
end;
end module body.H3012
Ein Wert wird negiert, dessen Typ keine Instanz der Typklasse TrappingNegation hat. Ein eigener Typ kann eine solche Instanz bekommen.
Meldung:
Dieses Modul scheitert mit H3012:
module body Example is
record Money: Free is
cents: Int64;
end;
function main(): ExitCode is
let debt: Money := Money(cents => 500);
let credit: Money := -debt;
printLn(credit.cents);
return ExitSuccess();
end;
end module body.H3020
Etwas, das weder eine Funktion noch eine Methode noch ein Funktionszeiger ist, wird aufgerufen.
Meldung:
Dieses Modul scheitert mit H3020:
module body Example is
function main(): ExitCode is
let n: Int32 := 5;
printLn(n(1));
return ExitSuccess();
end;
end module body.H3021
Ein Funktionszeiger wird mit mehr oder weniger Argumenten aufgerufen, als sein Typ Parameter hat. Ein direkter Aufruf einer Funktion mit falscher Anzahl wird als H6026 gemeldet.
Meldung:
Dieses Modul scheitert mit H3021:
module body Example is
function add(a: Int32, b: Int32): Int32 is
return a + b;
end;
function main(): ExitCode is
let f: Fn[Int32, Int32, Int32] := add;
let sum: Int32 := f(1);
printLn(sum);
return ExitSuccess();
end;
end module body.H3022
Ein case, das nach Namen bindet, lässt einen Fall der Union aus. Jeder Fall der Union braucht sein eigenes when.
Meldung:
Dieses Modul scheitert mit H3022:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Dot();
case s of
when Dot do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3023
Ein case schaut in eine Union, die ein anderes Modul nur als opaken Typ exportiert. Nur eine öffentliche oder im selben Modul deklarierte Union lässt sich mit case zerlegen.
Meldung:
Dieses Modul scheitert mit H3023:
import Library (Shape, make);
module body Example is
function main(): ExitCode is
case make() of
when Dot do
printLn(0);
when Circle(radius: Int32) do
printLn(radius);
end case;
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
type Shape: Free;
function make(): Shape;
end module.Daneben Library.hiq:
module body Library is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function make(): Shape is
return Circle(radius => 2);
end;
end module body.H3024
Ein case, das nach Namen bindet, bekommt einen Wert eines benannten Typs, der keine Union ist, etwa einen Record.
Meldung:
Dieses Modul scheitert mit H3024:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1);
case p of
when Point(x: Int32) do
printLn(x);
end case;
return ExitSuccess();
end;
end module body.H3025
Ein when, das nach Namen bindet, nennt Slots, die der Fall der Union nicht hat, oder lässt welche aus.
Meldung:
Dieses Modul scheitert mit H3025:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Circle(radius => 2);
case s of
when Dot do
printLn(0);
when Circle(diameter: Int32) do
printLn(diameter);
end case;
return ExitSuccess();
end;
end module body.H3027
Ein Wert wird in einen Typ umgewandelt, der er nicht werden kann. Eine Typangabe e : T gibt nur einem Literal seinen Typ, macht aus einer Schreib- eine Lese-Referenz oder nennt einem generischen Aufruf seinen Rückgabetyp.
Meldung:
Dieses Modul scheitert mit H3027:
module body Example is
function main(): ExitCode is
let flag: Bool := true;
let n: Int32 := flag : Int32;
printLn(n);
return ExitSuccess();
end;
end module body.H3029
Die Bedingung eines if, eines while oder eines if-Ausdrucks ist kein Bool.
Meldung:
Dieses Modul scheitert mit H3029:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
if n then
printLn(n);
end if;
return ExitSuccess();
end;
end module body.H3030
Ein Record oder ein Fall einer Union wird mit Argumenten nach Position gebaut. Sein Konstruktor nimmt nur benannte Argumente.
Meldung:
Dieses Modul scheitert mit H3030:
module body Example is
record Point: Free is
x: Int32;
y: Int32;
end;
function main(): ExitCode is
let p: Point := Point(1, 2);
printLn(p.x);
return ExitSuccess();
end;
end module body.H3031
Ein Konstruktor wird mit Namen aufgerufen, die nicht die Slots des Records oder des Falls sind.
Meldung:
Dieses Modul scheitert mit H3031:
module body Example is
record Point: Free is
x: Int32;
y: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1, z => 2);
printLn(p.x);
return ExitSuccess();
end;
end module body.H3033
Ein let mit geschweiften Klammern zerlegt einen Wert eines eingebauten Typs, der keine Slots hat. Eine Union wird als H3053 gemeldet.
Meldung:
Dieses Modul scheitert mit H3033:
module body Example is
function main(): ExitCode is
let n: Int32 := 5;
let { value: Int32 } := n;
printLn(value);
return ExitSuccess();
end;
end module body.H3034
Ein let mit geschweiften Klammern zerlegt einen Record, den ein anderes Modul nur als opaken Typ exportiert. Seine Slots sind außerhalb seines Moduls nicht sichtbar.
Meldung:
Dieses Modul scheitert mit H3034:
import Library (Point, make);
module body Example is
function main(): ExitCode is
let { x: Int32 } := make();
printLn(x);
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
type Point: Free;
function make(): Point;
end module.Daneben Library.hiq:
module body Library is
record Point: Free is
x: Int32;
end;
function make(): Point is
return Point(x => 1);
end;
end module body.H3035
Ein let mit geschweiften Klammern nennt andere Slots, als der Record hat. Jeder Slot wird genannt, und kein anderer.
Meldung:
Dieses Modul scheitert mit H3035:
module body Example is
record Point: Free is
x: Int32;
y: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1, y => 2);
let { x: Int32 } := p;
printLn(x);
return ExitSuccess();
end;
end module body.H3037
Eine Ausdrucksanweisung wirft ein Option oder ein Either weg. Ein solcher Wert trägt einen Fehlschlag, den jemand ansehen muss: mit case behandeln, mit ? weiterreichen oder mit ignore bewusst verwerfen.
Meldung:
Dieses Modul scheitert mit H3037:
module body Example is
function half(n: Int32): Option[Int32] is
let r: Option[Int32] := Some(value => n / 2);
return r;
end;
function main(): ExitCode is
half(4);
return ExitSuccess();
end;
end module body.H3038
Der Operator ? steht an einem Wert, der weder Option noch Either ist; es gibt also keinen Fehlschlag weiterzureichen.
Meldung:
Dieses Modul scheitert mit H3038:
module body Example is
function twice(n: Int32): Option[Int32] is
let m: Int32 := n?;
let r: Option[Int32] := Some(value => m * 2);
return r;
end;
function main(): ExitCode is
ignore(twice(2));
return ExitSuccess();
end;
end module body.H3039
Der Operator ? steht in einer Funktion, die den Fehlschlag nicht weiterreichen kann: Für ein Option muss sie ein Option zurückgeben, für ein Either ein Either mit demselben linken Typ.
Meldung:
Dieses Modul scheitert mit H3039:
module body Example is
function half(n: Int32): Option[Int32] is
let r: Option[Int32] := Some(value => n / 2);
return r;
end;
function quarter(n: Int32): Int32 is
let h: Int32 := half(n)?;
return h / 2;
end;
function main(): ExitCode is
printLn(quarter(8));
return ExitSuccess();
end;
end module body.H3040
Der Operator ? steht innerhalb eines größeren Ausdrucks. Er darf nur die ganze rechte Seite eines let oder eine ganze Anweisung sein, damit die vorzeitige Rückkehr in einer eigenen Zeile sichtbar ist.
Meldung:
Dieses Modul scheitert mit H3040:
module body Example is
function half(n: Int32): Option[Int32] is
let r: Option[Int32] := Some(value => n / 2);
return r;
end;
function quarter(n: Int32): Option[Int32] is
let q: Int32 := half(n)? / 2;
let r: Option[Int32] := Some(value => q);
return r;
end;
function main(): ExitCode is
ignore(quarter(8));
return ExitSuccess();
end;
end module body.H3041
Der Wert einer Konstanten ist kein konstanter Ausdruck, etwa ein Funktionsaufruf.
Meldung:
Dieses Modul scheitert mit H3041:
module body Example is
function five(): Int32 is
return 5;
end;
constant limit: Int32 := five();
function main(): ExitCode is
printLn(limit);
return ExitSuccess();
end;
end module body.H3043
Ein Funktionszeiger wird mit benannten Argumenten aufgerufen. Ein Funktionszeiger behält die Namen der Parameter nicht; seine Argumente stehen deshalb nach Position.
Meldung:
Dieses Modul scheitert mit H3043:
module body Example is
function add(a: Int32, b: Int32): Int32 is
return a + b;
end;
function main(): ExitCode is
let f: Fn[Int32, Int32, Int32] := add;
let sum: Int32 := f(a => 1, b => 2);
printLn(sum);
return ExitSuccess();
end;
end module body.H3044
Die beiden Zweige eines if-Ausdrucks haben verschiedene Typen.
Meldung:
Dieses Modul scheitert mit H3044:
module body Example is
function main(): ExitCode is
let flag: Bool := true;
printLn(if flag then 1 else false);
return ExitSuccess();
end;
end module body.H3045
Der Operand von not ist kein Bool.
Meldung:
Dieses Modul scheitert mit H3045:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
printLn(not n);
return ExitSuccess();
end;
end module body.H3046
Ein Operand von and oder or ist kein Bool.
Meldung:
Dieses Modul scheitert mit H3046:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
let flag: Bool := true;
printLn(n and flag);
return ExitSuccess();
end;
end module body.H3049
Ein Record hat keinen Slot dieses Namens.
Meldung:
Dieses Modul scheitert mit H3049:
module body Example is
record Point: Free is
x: Int32;
y: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1, y => 2);
printLn(p.z);
return ExitSuccess();
end;
end module body.H3050
Eine Methode einer Typklasse wird mit einem Wert aufgerufen, dessen Typ keine Instanz dieser Klasse hat.
Meldung:
Dieses Modul scheitert mit H3050:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
instance Describe(Bool) is
method describe(value: Bool): Int32 is
return 1;
end;
end;
function main(): ExitCode is
let n: Int32 := 5;
printLn(describe(n));
return ExitSuccess();
end;
end module body.H3052
Ein Slot wird aus einem Record gelesen, den ein anderes Modul nur als opaken Typ exportiert.
Meldung:
Dieses Modul scheitert mit H3052:
import Library (Point, make);
module body Example is
function main(): ExitCode is
let p: Point := make();
printLn(p.x);
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
type Point: Free;
function make(): Point;
end module.Daneben Library.hiq:
module body Library is
record Point: Free is
x: Int32;
end;
function make(): Point is
return Point(x => 1);
end;
end module body.H3053
Ein Slot wird aus einem Wert eines benannten Typs gelesen, der kein Record ist, etwa einer Union. Ein Wert eines eingebauten Typs wird als H3057 gemeldet.
Meldung:
Dieses Modul scheitert mit H3053:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Circle(radius => 2);
printLn(s.radius);
return ExitSuccess();
end;
end module body.H3054
Eine Bindung in einem case-Zweig deklariert einen anderen Typ, als der Slot hat.
Meldung:
Dieses Modul scheitert mit H3054:
module body Example is
function main(): ExitCode is
let count: Option[Int32] := Some(value => 5);
case count of
when Some(value as number: Int64) do
printLn(number);
when None do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3055
Eine generische Funktion, deren Typparameter nur im Rückgabetyp vorkommt, wird an einer Stelle aufgerufen, die keinen Typ erwartet; ihr Typ lässt sich so nicht bestimmen. Eine Typangabe mit Doppelpunkt legt ihn fest.
Meldung:
Dieses Modul scheitert mit H3055:
module body Example is
function main(): ExitCode is
ignore(None());
return ExitSuccess();
end;
end module body.H3056
In einer generischen Funktion wird eine Methode einer Typklasse auf einem Wert eines Typparameters aufgerufen, dem die Anforderung dieser Klasse fehlt.
Meldung:
Dieses Modul scheitert mit H3056:
module body Example is
generic [T: Free]
function show(value: T): Unit is
print(value);
return nil;
end;
function main(): ExitCode is
show(5);
return ExitSuccess();
end;
end module body.H3057
Ein Slot wird aus einem Wert eines eingebauten Typs gelesen, der keine Slots hat.
Meldung:
Dieses Modul scheitert mit H3057:
module body Example is
function main(): ExitCode is
let n: Int32 := 5;
printLn(n.value);
return ExitSuccess();
end;
end module body.H3058
Der Index-Operator s[i] steht an einem Wert, der kein Span ist.
Meldung:
Dieses Modul scheitert mit H3058:
module body Example is
record Box: Free is
value: Int32;
end;
function main(): ExitCode is
let b: Box := Box(value => 5);
printLn(b[0]);
return ExitSuccess();
end;
end module body.H3060
Ein Wert hat einen anderen Typ als den, den seine Stelle erwartet, etwa in einer return-Anweisung.
Meldung:
Dieses Modul scheitert mit H3060:
module body Example is
function answer(): Int32 is
return true;
end;
function main(): ExitCode is
printLn(answer());
return ExitSuccess();
end;
end module body.H3061
Eine generische Funktion verlangt von ihrem Typparameter eine Typklasse, und der dafür eingesetzte Typ hat keine Instanz dieser Klasse.
Meldung:
Dieses Modul scheitert mit H3061:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1);
printLn(p);
return ExitSuccess();
end;
end module body.H3062
Ein Ganzzahl-Literal passt nicht in seinen Typ.
Meldung:
Dieses Modul scheitert mit H3062:
module body Example is
function main(): ExitCode is
let n: Nat8 := 300;
printLn(n);
return ExitSuccess();
end;
end module body.H3063
Ein Typargument liegt in einem Universum, das sein Typparameter nicht annimmt, etwa ein Linear-Typ für einen Parameter in Free.
Meldung:
Dieses Modul scheitert mit H3063:
module body Example is
record Ticket: Linear is
number: Int32;
end;
record Box[T: Free]: Free is
content: T;
end;
function unpack(box: Box[Ticket]): Unit is
return nil;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3064
Ein Typname ist unbekannt: Er ist im Modul nicht deklariert, nicht importiert und nicht eingebaut.
Meldung:
Dieses Modul scheitert mit H3064:
module body Example is
function main(): ExitCode is
let n: Integer := 1;
printLn(n);
return ExitSuccess();
end;
end module body.H3065
Ein case, das nach Namen bindet, bekommt einen Wert, der weder eine Union noch eine Referenz auf eine Union ist.
Meldung:
Dieses Modul scheitert mit H3065:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
case n of
when Some(value: Int32) do
printLn(value);
when None do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3071
Ein case verwendet in einem when Muster und bindet in einem anderen Slots nach Name und Typ. Ein case tut in allen seinen whens das eine oder das andere.
Meldung:
Dieses Modul scheitert mit H3071:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Circle(radius => 2);
case s of
when Dot | Circle(0) do
printLn(0);
when Circle(radius: Int32) do
printLn(radius);
end case;
return ExitSuccess();
end;
end module body.H3072
Ein case mit Mustern bekommt eine Referenz. Muster passen auf einen Wert; auf Referenzen arbeitet ein case, das nach Namen bindet.
Meldung:
Dieses Modul scheitert mit H3072:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Circle(radius => 2);
case &s of
when Dot do
printLn(0);
when Circle(r) do
printLn(r);
end case;
return ExitSuccess();
end;
end module body.H3073
Eine Variable steht als ganzes Muster in einem case über einer Union. Sie würde auf jeden Wert passen, und ein case über einer Union hat keinen Auffangzweig: Jede Variante wird aufgeführt.
Meldung:
Dieses Modul scheitert mit H3073:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Circle(radius => 2);
case s of
when Dot do
printLn(0);
when other do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3074
Ein Muster kann nie gewählt werden, weil die Muster davor schon jeden Wert erfassen, auf den es passt.
Meldung:
Dieses Modul scheitert mit H3074:
module body Example is
function main(): ExitCode is
let n: Nat8 := 5;
case n of
when 0 .. 9 do
printLn(1);
when 5 do
printLn(2);
when _ do
printLn(3);
end case;
return ExitSuccess();
end;
end module body.H3075
Ein case mit Mustern lässt Werte aus. Die Meldung nennt einen davon; bei einer ganzen Zahl schließt eine Variable oder _ am Ende das case ab.
Meldung:
Dieses Modul scheitert mit H3075:
module body Example is
function main(): ExitCode is
let n: Nat8 := 5;
case n of
when 0 .. 9 do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3076
Ein Ganzzahl-Muster steht, wo der Wert keine ganze Zahl ist.
Meldung:
Dieses Modul scheitert mit H3076:
module body Example is
function main(): ExitCode is
let flag: Bool := true;
case flag of
when 1 do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3077
Ein Bool-Muster, true oder false, steht, wo der Wert kein Bool ist.
Meldung:
Dieses Modul scheitert mit H3077:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
case n of
when true do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3078
Ein Literal oder eine Grenze eines Bereichs liegt außerhalb des Typs des Werts. Ein Muster schneidet ein Literal nie ab und rechnet es nie um.
Meldung:
Dieses Modul scheitert mit H3078:
module body Example is
function main(): ExitCode is
let n: Nat8 := 5;
case n of
when 256 do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3079
Die untere Grenze eines Bereichs liegt über der oberen; der Bereich ist leer.
Meldung:
Dieses Modul scheitert mit H3079:
module body Example is
function main(): ExitCode is
let n: Nat8 := 5;
case n of
when 9 .. 0 do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3080
Ein Gleitkomma-Literal steht als Muster. Zwei Gleitkommazahlen, die gleich aussehen, müssen nicht gleich sein; Gleitkommazahlen sind deshalb keine Muster. Man bindet den Wert und vergleicht im Rumpf.
Meldung:
Dieses Modul scheitert mit H3080:
module body Example is
function main(): ExitCode is
let x: Int32 := 1;
case x of
when 1.5 do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3081
Ein String-Literal steht als Muster. Muster sind nur Ganzzahl- und Bool-Literale.
Meldung:
Dieses Modul scheitert mit H3081:
module body Example is
function main(): ExitCode is
let x: Int32 := 1;
case x of
when "one" do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3082
Das Muster _ steht, wo der Wert nicht Free ist. Es würde einen linearen Wert fallen lassen, den niemand verbraucht; man bindet ihn an eine Variable und verbraucht ihn.
Meldung:
Dieses Modul scheitert mit H3082:
module body Example is
record Ticket: Linear is
number: Int32;
end;
union Slot: Linear is
case Empty;
case Full is
ticket: Ticket;
end;
function main(): ExitCode is
let s: Slot := Empty();
case s of
when Empty do
printLn(0);
when Full(_) do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3083
Ein Variantenmuster gibt mehr oder weniger Untermuster an, als die Variante Slots hat. Jeder Slot bekommt eines, in der Reihenfolge der Deklaration.
Meldung:
Dieses Modul scheitert mit H3083:
module body Example is
union Shape: Free is
case Dot;
case Rectangle is
width: Int32;
height: Int32;
end;
function main(): ExitCode is
let s: Shape := Dot();
case s of
when Dot do
printLn(0);
when Rectangle(w) do
printLn(w);
end case;
return ExitSuccess();
end;
end module body.H3084
Die Alternativen eines when binden verschiedene Variablen. Der Rumpf läuft nach jeder von ihnen; alle binden deshalb dieselben Variablen.
Meldung:
Dieses Modul scheitert mit H3084:
module body Example is
union Shape: Free is
case Square is
side: Int32;
case Rectangle is
width: Int32;
height: Int32;
end;
function main(): ExitCode is
let s: Shape := Square(side => 2);
case s of
when Square(a) | Rectangle(b, _) do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3085
Eine Variable hat in einer Alternative eines when einen Typ und in einer anderen einen anderen.
Meldung:
Dieses Modul scheitert mit H3085:
module body Example is
union Value: Free is
case Small is
n: Int8;
case Large is
n: Int64;
end;
function main(): ExitCode is
let v: Value := Small(n => 1);
case v of
when Small(x) | Large(x) do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3086
Ein Muster bindet dieselbe Variable zweimal. Um zwei Teile zu vergleichen, bindet man beide unter verschiedenen Namen und vergleicht im Rumpf.
Meldung:
Dieses Modul scheitert mit H3086:
module body Example is
union Shape: Free is
case Rectangle is
width: Int32;
height: Int32;
end;
function main(): ExitCode is
let s: Shape := Rectangle(width => 2, height => 2);
case s of
when Rectangle(a, a) do
printLn(a);
end case;
return ExitSuccess();
end;
end module body.H3087
Ein Name mit kleinem Anfangsbuchstaben hat Untermuster. Ein solcher Name ist eine Variable; Untermuster hat nur eine Variante, mit großem Anfangsbuchstaben.
Meldung:
Dieses Modul scheitert mit H3087:
module body Example is
union Shape: Free is
case Dot;
case circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Dot();
case s of
when Dot do
printLn(0);
when circle(r) do
printLn(r);
end case;
return ExitSuccess();
end;
end module body.H3088
Ein Variantenmuster nennt einen Fall, den die Union nicht hat. Die Meldung zählt ihre Varianten auf.
Meldung:
Dieses Modul scheitert mit H3088:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Dot();
case s of
when Dot do
printLn(0);
when Square(r) do
printLn(r);
end case;
return ExitSuccess();
end;
end module body.H3089
Ein Variantenmuster steht, wo der Wert keine Union ist.
Meldung:
Dieses Modul scheitert mit H3089:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
case n of
when Some(x) do
printLn(x);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3090
Ein case mit Mustern bekommt einen Wert eines Typs, über den es nicht entscheiden kann. Muster entscheiden über eine Union, eine ganze Zahl oder ein Bool.
Meldung:
Dieses Modul scheitert mit H3090:
module body Example is
function main(): ExitCode is
let x: Float64 := 1.0;
case x of
when y do
printLn(y);
end case;
return ExitSuccess();
end;
end module body.H3091
Das Muster _ steht als ganzes Muster in einem case über einer Union. Ein case über einer Union hat keinen Auffangzweig: Jede Variante wird aufgeführt.
Meldung:
Dieses Modul scheitert mit H3091:
module body Example is
union Shape: Free is
case Dot;
case Circle is
radius: Int32;
end;
function main(): ExitCode is
let s: Shape := Dot();
case s of
when Dot do
printLn(0);
when _ do
printLn(1);
end case;
return ExitSuccess();
end;
end module body.H3092
Ein Bereich steht, wo der Wert keine ganze Zahl ist.
Meldung:
Dieses Modul scheitert mit H3092:
module body Example is
function main(): ExitCode is
let flag: Bool := true;
case flag of
when 0 .. 1 do
printLn(1);
when _ do
printLn(0);
end case;
return ExitSuccess();
end;
end module body.H3093
Eine Schreib-Referenz auf einen Teil eines Werts wird über eine Lese-Referenz genommen. &!(path) braucht einen Pfad, der bei einer Schreib-Referenz beginnt; über eine Lese-Referenz liest nur &(path) den Teil.
Meldung:
Dieses Modul scheitert mit H3093:
module body Example is
record Inner: Linear is
value: Int32;
end;
record Pair: Linear is
first: Inner;
second: Inner;
end;
generic [R: Region]
function setValue(inner: &![Inner, R], value: Int32): Unit is
inner->value := value;
return nil;
end;
generic [R: Region]
function clear(pair: &[Pair, R]): Unit is
setValue(&!(pair->first), 0);
return nil;
end;
function main(): ExitCode is
let pair: Pair := Pair(first => Inner(value => 5), second => Inner(value => 0));
clear(&pair);
let { first: Inner, second: Inner } := pair;
let { value as a: Int32 } := first;
let { value as b: Int32 } := second;
return ExitSuccess();
end;
end module body.H3094
Eine Funktion gibt eine Referenz auf eine ihrer lokalen Variablen in einer Region zurück, die ihr Aufrufer wählt. Die Region des Aufrufers überdauert den Aufruf, die lokale Variable nicht.
Meldung:
Dieses Modul scheitert mit H3094:
module body Example is
generic [R: Region]
function local(n: Int32): &[Int32, R] is
let x: Int32 := n;
return &x;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3095
Der Rumpf einer generischen Funktion legt einen der Typparameter der Funktion fest. Was ein Typparameter bedeutet, wählt der Aufrufer; der Rumpf muss deshalb für jede Wahl funktionieren.
Meldung:
Dieses Modul scheitert mit H3095:
module body Example is
generic [T: Type]
function pretend(n: Int32): T is
return n;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H4001
Ein als Free deklarierter Record oder eine solche Union enthält einen Slot eines Linear-Typs oder hat einen Typparameter, der nicht Free ist. Ein Free-Wert ließe sich kopieren, und der lineare Wert darin mit ihm.
Meldung:
Dieses Modul scheitert mit H4001:
module body Example is
record Ticket: Linear is
number: Int32;
end;
record Wallet: Free is
ticket: Ticket;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6026
Eine Funktion, eine Methode oder ein Konstruktor wird mit mehr oder weniger Argumenten aufgerufen, als sie Parameter hat.
Meldung:
Dieses Modul scheitert mit H6026:
module body Example is
function add(a: Int32, b: Int32): Int32 is
return a + b;
end;
function main(): ExitCode is
printLn(add(1));
return ExitSuccess();
end;
end module body.H6032
Eine Instanz verbindet eine Typklasse und einen Typ, die beide aus anderen Modulen stammen. Eine Instanz gehört in das Modul ihrer Typklasse oder ihres Typs.
Meldung:
Dieses Modul scheitert mit H6032:
module body Example is
instance Printable(ExitCode) is
method print(value: ExitCode): Unit is
return nil;
end;
generic [R: Region]
method printSpan(value: Span[ExitCode, R]): Unit is
return nil;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6037
Eine Instanz einer Typklasse aus einem anderen Modul wird für einen eingebauten Typ angegeben. Ein eingebauter Typ gehört der Sprache und gilt deshalb in jedem Modul als fremd; man definiert einen eigenen Typ und gibt diesem die Instanz.
Meldung:
Dieses Modul scheitert mit H6037:
module body Example is
instance TrappingNegation(Nat8) is
method trappingNegate(value: Nat8): Nat8 is
return value;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6038
Ein Typ bekommt eine zweite Instanz derselben Typklasse. In einem Programm hat ein Typ höchstens eine Instanz einer Typklasse, gleich welches Modul sie deklariert.
Meldung:
Dieses Modul scheitert mit H6038:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
instance Describe(Bool) is
method describe(value: Bool): Int32 is
return 1;
end;
end;
instance Describe(Bool) is
method describe(value: Bool): Int32 is
return 2;
end;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6039
Ein aufgerufener Name ist weder eine Funktion noch eine Methode noch eine sichtbare Variable.
Meldung:
Dieses Modul scheitert mit H6039:
module body Example is
function main(): ExitCode is
printLn(twice(2));
return ExitSuccess();
end;
end module body.H6041
Links in einer Zuweisung steht ein Parameter der Funktion. Parameter lassen sich nicht ändern; der Wert wird zuerst in ein var kopiert.
Meldung:
Dieses Modul scheitert mit H6041:
module body Example is
function next(n: Int32): Int32 is
n := n + 1;
return n;
end;
function main(): ExitCode is
printLn(next(1));
return ExitSuccess();
end;
end module body.H6042
Eine Zuweisung ändert eine mit let gebundene Variable. Eine Variable, die sich ändert, wird mit var gebunden.
Meldung:
Dieses Modul scheitert mit H6042:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
n := 2;
printLn(n);
return ExitSuccess();
end;
end module body.H6045
Eine Variable heißt wie eine Deklaration des Moduls, etwa eine Funktion oder eine Konstante.
Meldung:
Dieses Modul scheitert mit H6045:
module body Example is
constant limit: Int32 := 5;
function main(): ExitCode is
let limit: Int32 := 6;
printLn(limit);
return ExitSuccess();
end;
end module body.H6048
Ein generischer Typ oder ein eingebauter Typ wie Pointer bekommt die falsche Anzahl von Typargumenten.
Meldung:
Dieses Modul scheitert mit H6048:
module body Example is
function main(): ExitCode is
let n: Option[Int32, Bool] := None();
ignore(n);
return ExitSuccess();
end;
end module body.H3105
Eine Einschränkung einer generischen Funktion nennt eine Typklasse, die das Modul der Funktion weder im Interface noch im Rumpf importiert. Ein Modul importiert jede Typklasse, die seine Einschränkungen nennen; ohne diese Prüfung hielte das den Compiler mit einem internen Fehler an.
Meldung:
Dieses Modul scheitert mit H3105:
import Shape (Sized);
import Measure (measure);
module body Example is
function main(): ExitCode is
printLn(measure(5));
return ExitSuccess();
end;
end module body.Daneben Shape.hih:
module Shape is
typeclass Sized(T: Free) is
method sizeOf(value: T): Int32;
end;
instance Sized(Int32);
end module.Daneben Shape.hiq:
module body Shape is
instance Sized(Int32) is
method sizeOf(value: Int32): Int32 is
return 4;
end;
end;
end module body.Daneben Measure.hih:
module Measure is
generic [T: Free(Sized)]
function measure(value: T): Int32;
end module.Daneben Measure.hiq:
module body Measure is
generic [T: Free(Sized)]
function measure(value: T): Int32 is
return 0;
end;
end module body.H3106
Der Compiler deklariert eine aus C importierte Funktion unter einem eigenen Namen, also ist der C-Name im Text eines @embed nicht deklariert, und cc wies das Programm mit einer impliziten Deklaration ab. Aufgerufen wird stattdessen die Hilde-Funktion, die sie importiert. Eine Funktion, die die Laufzeit deklariert, ist auch unter ihrem C-Namen deklariert, und ein @embed darf sie aufrufen, während ein Modul sie importiert.
Meldung:
Dieses Modul scheitert mit H3106:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Import(External_Name => "abs");
function cAbs(n: Int32): Int32 is
end;
function main(): ExitCode is
let n: Int32 := @embed(Int32, "abs($1)", -3);
printLn(n);
return ExitSuccess();
end;
end module body.H3107
Ein Vergleich wird zum Operator von C, der nur Skalare und Zeiger vergleicht. Zwei Spans, zwei Records oder zwei Unions kämen ohne diese Prüfung durch die Typprüfung, und cc wiese das erzeugte C mit ungültigen Operanden ab. Zwei Texte vergleicht man Byte für Byte mit Standard.Text.equal, einen Record mit einer Funktion, die seine Felder vergleicht. Eine Typvariable kommt hier durch; H3108 ist dieselbe Prüfung dort, wo ein Aufruf ihr ihren Typ gibt.
Meldung:
Dieses Modul scheitert mit H3107:
module body Example is
function main(): ExitCode is
let text: Span[Nat8, Static] := "export PATH";
let word: Span[Nat8, Static] := spanPart(text, 0, 7);
if word = "export " then
printLn("an export");
end if;
return ExitSuccess();
end;
end module body.H3108
Die Typprüfung lässt einen Vergleich von Werten einer Typvariable durch, denn eine generische Funktion, die Zahlen vergleicht, ist richtig. Wo ein Aufruf der Variable einen Span, einen Record oder eine Union gibt, wird der Vergleich an dieser Instanz abgewiesen, wie H3107 ihn für einen ausgeschriebenen Typ abweist; ohne sie wiese cc das erzeugte C ab.
Meldung:
Dieses Modul scheitert mit H3108:
module body Example is
generic [T: Free]
function same(a: T, b: T): Bool is
return a = b;
end;
function main(): ExitCode is
let left: Span[Nat8, Static] := "a";
let right: Span[Nat8, Static] := "a";
printLn(same(left, right));
return ExitSuccess();
end;
end module body.H3111
Ein Aufruf einer Methode findet die gemeinte Instanz über den Typ, der für den Parameter der Klasse steht: in einem Argument oder in dem Typ, als den das Ergebnis genommen wird. Eine Methode, die den Parameter in keinem von beiden nennt, lässt jeden Aufruf ohne Instanz; bisher kam die Typprüfung bis zu einem solchen Aufruf und brach mit einem internen Fehler ab. Die Methode wird abgewiesen, wo die Typklasse sie deklariert.
Meldung:
Dieses Modul scheitert mit H3111:
module body Example is
typeclass Sized(T: Free) is
method size(): Index;
end;
instance Sized(Int32) is
method size(): Index is
return 4;
end;
end;
function main(): ExitCode is
printLn(size());
return ExitSuccess();
end;
end module body.3. Linearität
H3036
Eine Ausdrucksanweisung wirft einen Wert eines Linear-Typs weg. Ein linearer Wert wird verbraucht: an eine Funktion übergeben, zurückgegeben oder zerlegt.
Meldung:
Dieses Modul scheitert mit H3036:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function main(): ExitCode is
Ticket(number => 1);
return ExitSuccess();
end;
end module body.H4002
Eine lineare Variable verlässt ihren Gültigkeitsbereich, ohne verbraucht zu sein, etwa eine Variable, die ein when bindet und sein Rumpf nicht verwendet.
Meldung:
Dieses Modul scheitert mit H4002:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 1);
let held: Option[Ticket] := Some(value => ticket);
case held of
when Some(value: Ticket) do
skip;
when None do
skip;
end case;
return ExitSuccess();
end;
end module body.H4003
Eine lineare Variable von außerhalb einer Schleife wird im Rumpf verbraucht und bekommt vor dessen Ende keinen neuen Wert. Der nächste Durchlauf würde sie ein zweites Mal verwenden.
Meldung:
Dieses Modul scheitert mit H4003:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
for i from 1 to 3 do
printLn(redeem(ticket));
end for;
return ExitSuccess();
end;
end module body.H4004
Die Zweige eines if oder eines case behandeln eine lineare Variable verschieden: einer verbraucht sie, ein anderer nicht.
Meldung:
Dieses Modul scheitert mit H4004:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
let lucky: Bool := true;
if lucky then
printLn(redeem(ticket));
else
skip;
end if;
return ExitSuccess();
end;
end module body.H4005
Ein einziger Ausdruck verbraucht dieselbe lineare Variable zweimal, etwa als zwei Argumente eines Aufrufs.
Meldung:
Dieses Modul scheitert mit H4005:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function both(a: Ticket, b: Ticket): Int32 is
let { number as x: Int32 } := a;
let { number as y: Int32 } := b;
return x + y;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
printLn(both(ticket, ticket));
return ExitSuccess();
end;
end module body.H4008
Eine lineare Variable wird in einer späteren Anweisung ein zweites Mal verbraucht.
Meldung:
Dieses Modul scheitert mit H4008:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
printLn(redeem(ticket));
printLn(redeem(ticket));
return ExitSuccess();
end;
end module body.H4010
Einer var mit einem linearen Wert wird ein neuer Wert zugewiesen, bevor der alte verbraucht ist. Der alte Wert ginge verloren.
Meldung:
Dieses Modul scheitert mit H4010:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
var ticket: Ticket := Ticket(number => 1);
ticket := Ticket(number => 2);
printLn(redeem(ticket));
return ExitSuccess();
end;
end module body.H4012
Eine lineare Variable ist nicht verbraucht, wenn die Funktion zurückkehrt.
Meldung:
Dieses Modul scheitert mit H4012:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
return ExitSuccess();
end;
end module body.H4014
Eine Zuweisung an einen Slot schreibt einen Wert eines Typs, der nicht Free ist. Der alte Wert im Slot ginge verloren, ohne verbraucht zu sein.
Meldung:
Dieses Modul scheitert mit H4014:
module body Example is
record Ticket: Linear is
number: Int32;
end;
record Wallet: Linear is
ticket: Ticket;
end;
function main(): ExitCode is
var wallet: Wallet := Wallet(ticket => Ticket(number => 1));
wallet.ticket := Ticket(number => 2);
let { ticket: Ticket } := wallet;
let { number: Int32 } := ticket;
printLn(number);
return ExitSuccess();
end;
end module body.H4015
Von einem if-Ausdruck läuft ein Zweig. Eine lineare Variable, die nur ein Zweig verbraucht, bleibt auf dem anderen Weg unverbraucht. Beide Zweige verbrauchen sie, oder sie wird vor dem if verbraucht.
Meldung:
Dieses Modul scheitert mit H4015:
module body Example is
record Box: Linear is
content: Int32;
end;
function open(box: Box): Int32 is
let { content: Int32 } := box;
return content;
end;
function main(): ExitCode is
let box: Box := Box(content => 7);
let full: Bool := true;
let value: Int32 := if full then open(box) else 0;
printLn(value);
return ExitSuccess();
end;
end module body.4. Borrowing
H3002
Eine Referenz oder ein Span wird an einen Task übergeben. Ein Task kann länger leben als die Ausleihe, aus der die Referenz stammt; sein Argument besitzt deshalb alles, worauf es zeigt.
Meldung:
Dieses Modul scheitert mit H3002:
import Standard.Task (Scope, openScope, closeScope, Task, spawn, join);
module body Example is
generic [R: Region]
function read(n: &[Index, R]): Index is
return !n;
end;
function main(): ExitCode is
let n: Index := 5;
case openScope() of
when Some(value as opened: Scope) do
var scope: Scope := opened;
borrow r: &[Index, rho] := &n do
let work: Fn[&[Index, rho], Index] := read;
case spawn(&!scope, work, r) of
when Right(right as task: Task[Index]) do
printLn(join(task));
when Left(left as back: &[Index, rho]) do
printLn(0);
end case;
end borrow;
closeScope(scope);
when None do
skip;
end case;
return ExitSuccess();
end;
end module body.H3005
Der Pfeil -> liest einen Slot über eine Referenz, und der Wert davor ist keine Referenz. Einen Slot eines Record-Werts liest man mit einem Punkt.
Meldung:
Dieses Modul scheitert mit H3005:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1);
printLn(p->x);
return ExitSuccess();
end;
end module body.H3018
Eine mit let gebundene Variable wird zum Schreiben ausgeliehen. Eine Variable, die zum Schreiben ausgeliehen wird, wird mit var gebunden.
Meldung:
Dieses Modul scheitert mit H3018:
module body Example is
record Counter: Linear is
count: Int32;
end;
generic [R: Region]
function bump(counter: &![Counter, R]): Unit is
counter->count := counter->count + 1;
return nil;
end;
function main(): ExitCode is
let counter: Counter := Counter(count => 0);
bump(&!counter);
let { count: Int32 } := counter;
printLn(count);
return ExitSuccess();
end;
end module body.H3019
Ein Parameter einer Funktion wird zum Schreiben ausgeliehen. Parameter lassen sich nicht ändern; man übernimmt den Wert zuerst in ein var, wie die Meldung vorschlägt.
Meldung:
Dieses Modul scheitert mit H3019:
module body Example is
record Counter: Linear is
count: Int32;
end;
generic [R: Region]
function bump(counter: &![Counter, R]): Unit is
counter->count := counter->count + 1;
return nil;
end;
function bumped(counter: Counter): Counter is
bump(&!counter);
return counter;
end;
function main(): ExitCode is
let counter: Counter := bumped(Counter(count => 0));
let { count: Int32 } := counter;
printLn(count);
return ExitSuccess();
end;
end module body.H3026
Eine Schreib-Referenz wird mit Doppelpunkt in eine Lese-Referenz eines anderen Typs oder einer anderen Region umgewandelt. Die Umwandlung behält beides bei.
Meldung:
Dieses Modul scheitert mit H3026:
module body Example is
record Account: Linear is
balance: Int64;
end;
generic [R: Region]
function peek(account: &![Account, R]): Int64 is
let r: &[Int64, R] := account : &[Int64, R];
return !r;
end;
function main(): ExitCode is
var account: Account := Account(balance => 5);
printLn(peek(&!account));
let { balance: Int64 } := account;
printLn(balance);
return ExitSuccess();
end;
end module body.H3028
Eine Schreib-Referenz wird mit Doppelpunkt in etwas umgewandelt, das keine Lese-Referenz ist.
Meldung:
Dieses Modul scheitert mit H3028:
module body Example is
record Account: Linear is
balance: Int64;
end;
generic [R: Region]
function peek(account: &![Account, R]): Int64 is
let n: Int64 := account : Int64;
return n;
end;
function main(): ExitCode is
var account: Account := Account(balance => 5);
printLn(peek(&!account));
let { balance: Int64 } := account;
printLn(balance);
return ExitSuccess();
end;
end module body.H3032
Der Operator ! liest den Wert hinter einer Referenz und steht hier an etwas, das keine Referenz ist.
Meldung:
Dieses Modul scheitert mit H3032:
module body Example is
function main(): ExitCode is
let n: Int32 := 5;
printLn(!n);
return ExitSuccess();
end;
end module body.H3066
Ein Task eines Lending-Scopes bekommt eine Referenz aus einer anderen Ausleihe als der, aus der der Scope verleiht. Diese andere Ausleihe kann enden, bevor der Scope geschlossen ist.
Meldung:
Dieses Modul scheitert mit H3066:
import Standard.Task (Lending, openLending, closeLending, Task, spawnLending, join);
module body Example is
generic [R: Region]
function read(n: &[Index, R]): Index is
return !n;
end;
function main(): ExitCode is
let outer: Index := 1;
let inner: Index := 2;
borrow o: &[Index, rho] := &outer do
case openLending(o) of
when Some(value as opened: Lending[rho]) do
var scope: Lending[rho] := opened;
borrow i: &[Index, sigma] := &inner do
let work: Fn[&[Index, sigma], Index] := read;
case spawnLending(&!scope, work, i) of
when Right(right as task: Task[Index]) do
printLn(join(task));
when Left(left as back: &[Index, sigma]) do
printLn(0);
end case;
end borrow;
closeLending(scope);
when None do
skip;
end case;
end borrow;
return ExitSuccess();
end;
end module body.H3067
Ein Task eines Lending-Scopes bekommt eine Schreib-Referenz. Tasks eines Lending-Scopes dürfen nur lesen, was ihnen geliehen wird.
Meldung:
Dieses Modul scheitert mit H3067:
import Standard.Task (Lending, openLending, closeLending, Task, spawnLending, join);
module body Example is
generic [R: Region]
function read(n: &![Index, R]): Index is
return !n;
end;
function main(): ExitCode is
let anchor: Index := 1;
var value: Index := 2;
borrow a: &[Index, rho] := &anchor do
case openLending(a) of
when Some(value as opened: Lending[rho]) do
var scope: Lending[rho] := opened;
borrow w: &![Index, sigma] := &!value do
let work: Fn[&![Index, sigma], Index] := read;
case spawnLending(&!scope, work, w) of
when Right(right as task: Task[Index]) do
printLn(join(task));
when Left(left as back: &![Index, sigma]) do
printLn(0);
end case;
end borrow;
closeLending(scope);
when None do
skip;
end case;
end borrow;
return ExitSuccess();
end;
end module body.H3068
Ein Task eines Lending-Scopes wird mit einem Argument gestartet, dessen Typ eine Typvariable ist. Wofür sie steht, ist dort, wo der Task startet, nicht bekannt; die Regionen lassen sich dort nicht prüfen.
Meldung:
Dieses Modul scheitert mit H3068:
import Standard.Task (Lending, openLending, closeLending, Task, spawnLending, join);
module body Example is
generic [R: Region]
function read(n: &[Index, R]): Index is
return !n;
end;
generic [T: Free, R: Region, S: Region]
function start(scope: &![Lending[R], S], work: Fn[T, Index], argument: T): Index is
case spawnLending(scope, work, argument) of
when Right(right as task: Task[Index]) do
return join(task);
when Left(left as back: T) do
return 0;
end case;
end;
function main(): ExitCode is
let n: Index := 5;
borrow w: &[Index, rho] := &n do
case openLending(w) of
when Some(value as opened: Lending[rho]) do
var scope: Lending[rho] := opened;
let work: Fn[&[Index, rho], Index] := read;
printLn(start(&!scope, work, w));
closeLending(scope);
when None do
skip;
end case;
end borrow;
return ExitSuccess();
end;
end module body.H3069
Ein Lending-Scope wird an einen Task eines anderen Lending-Scopes übergeben. Ein Task, der einen Scope hält, könnte ihn offen halten, nachdem seine Ausleihe geendet hat; ein Scope wird dort geschlossen, wo er geöffnet wurde.
Meldung:
Dieses Modul scheitert mit H3069:
import Standard.Task (Lending, openLending, closeLending, Task, spawnLending, join);
module body Example is
generic [R: Region]
function finish(scope: Lending[R]): Unit is
closeLending(scope);
return nil;
end;
function main(): ExitCode is
let n: Index := 5;
borrow w: &[Index, rho] := &n do
case openLending(w) of
when Some(value as opened: Lending[rho]) do
var scope: Lending[rho] := opened;
case openLending(w) of
when Some(value as other: Lending[rho]) do
let work: Fn[Lending[rho], Unit] := finish;
case spawnLending(&!scope, work, other) of
when Right(right as task: Task[Unit]) do
let done: Unit := join(task);
when Left(left as back: Lending[rho]) do
closeLending(back);
end case;
when None do
skip;
end case;
closeLending(scope);
when None do
skip;
end case;
end borrow;
return ExitSuccess();
end;
end module body.H3070
Ein Lending-Scope wird an einen Task eines gewöhnlichen Scopes übergeben. Der Task könnte den Lending-Scope offen halten, nachdem die Ausleihe, aus der er verleiht, geendet hat.
Meldung:
Dieses Modul scheitert mit H3070:
import Standard.Task (Scope, openScope, closeScope, Lending, openLending, closeLending, Task, spawn, join);
module body Example is
generic [R: Region]
function finish(scope: Lending[R]): Unit is
closeLending(scope);
return nil;
end;
function main(): ExitCode is
let n: Index := 5;
case openScope() of
when Some(value as opened: Scope) do
var plain: Scope := opened;
borrow w: &[Index, rho] := &n do
case openLending(w) of
when Some(value as lending: Lending[rho]) do
let work: Fn[Lending[rho], Unit] := finish;
case spawn(&!plain, work, lending) of
when Right(right as task: Task[Unit]) do
let done: Unit := join(task);
when Left(left as back: Lending[rho]) do
closeLending(back);
end case;
when None do
skip;
end case;
end borrow;
closeScope(plain);
when None do
skip;
end case;
return ExitSuccess();
end;
end module body.H3112
Ein Wert eines mit pragma Thread_Bound markierten Typs oder eines Typs, der einen solchen enthält, wird einem Task übergeben, durch einen Kanal geschickt oder von einem Mutex bewacht. Ein solcher Wert hält Zustand des Threads, der ihn erzeugt hat, und ein Task kann auf jedem Worker-Thread laufen. Geprüft wird am instanziierten Typ, also wird auch eine generische Funktion abgelehnt, die den Wert weiterreicht. Geprüft werden Standard.Task.spawn und spawnLending (Argument und Ergebnis), Standard.Task.openChannel und Standard.Shared.makeMutex.
Meldung:
Dieses Modul scheitert mit H3112:
import Standard.Task (Scope, openScope, closeScope, Task, spawn, join);
module body Example is
pragma Thread_Bound;
record Handle: Free is
number: Int32;
end;
function read(handle: Handle): Int32 is
return handle.number;
end;
function main(): ExitCode is
case openScope() of
when Some(value as opened: Scope) do
var scope: Scope := opened;
let work: Fn[Handle, Int32] := read;
case spawn(&!scope, work, Handle(number => 7)) of
when Right(right as task: Task[Int32]) do
printLn(join(task));
when Left(left as back: Handle) do
printLn(back.number);
end case;
closeScope(scope);
when None do
skip;
end case;
return ExitSuccess();
end;
end module body.H4006
Eine Variable wird verbraucht, während sie zum Lesen ausgeliehen ist.
Meldung:
Dieses Modul scheitert mit H4006:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
borrow view: &[Ticket, R] := &ticket do
printLn(redeem(ticket));
end borrow;
return ExitSuccess();
end;
end module body.H4007
Eine Variable wird verbraucht, während sie zum Schreiben ausgeliehen ist.
Meldung:
Dieses Modul scheitert mit H4007:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
var ticket: Ticket := Ticket(number => 7);
borrow view: &![Ticket, R] := &!ticket do
printLn(redeem(ticket));
end borrow;
return ExitSuccess();
end;
end module body.H4011
Eine Variable wird ausgeliehen, die schon verbraucht ist oder deren Zustand diese Art des Ausleihens nicht zulässt.
Meldung:
Dieses Modul scheitert mit H4011:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function redeem(ticket: Ticket): Int32 is
let { number: Int32 } := ticket;
return number;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
printLn(redeem(ticket));
borrow view: &[Ticket, R] := &ticket do
printLn(view->number);
end borrow;
return ExitSuccess();
end;
end module body.H4013
Der Operator ! liest den Wert hinter einer Referenz auf einen Typ, der nicht Free ist. Das Lesen würde einen linearen Wert kopieren.
Meldung:
Dieses Modul scheitert mit H4013:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function main(): ExitCode is
let ticket: Ticket := Ticket(number => 7);
borrow view: &[Ticket, R] := &ticket do
let copy: Ticket := !view;
let { number: Int32 } := copy;
printLn(number);
end borrow;
let { number: Int32 } := ticket;
return ExitSuccess();
end;
end module body.H6043
Eine Referenz-Transformation &( ... ) nimmt einen Pfad, dessen Kopf keine Referenz ist. Der Kopf ist eine Referenz, und der Pfad geht mit einem Pfeil weiter.
Meldung:
Dieses Modul scheitert mit H6043:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1);
let r: &[Int32, Static] := &(p.x);
printLn(!r);
return ExitSuccess();
end;
end module body.H6054
Eine Zuweisung schreibt über eine Lese-Referenz, die in einer var steht. Ändern lässt sich nur über eine Schreib-Referenz: zum Schreiben ausleihen und die Schreib-Referenz in die var legen.
Meldung:
Dieses Modul scheitert mit H6054:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
let p: Point := Point(x => 1);
borrow q: &[Point, R] := &p do
var r: &[Point, R] := q;
r->x := 0;
end borrow;
printLn(p.x);
return ExitSuccess();
end;
end module body.H6055
Eine borrow-Anweisung leiht mit &~ eine Variable weiter, die keine Schreib-Referenz ist.
Meldung:
Dieses Modul scheitert mit H6055:
module body Example is
record Point: Free is
x: Int32;
end;
function main(): ExitCode is
var p: Point := Point(x => 1);
borrow r: &![Point, R] := &~p do
printLn(r->x);
end borrow;
return ExitSuccess();
end;
end module body.H6059
Index und Feld werden über eine Ausleihe einer Variablen gelesen, und eine Konstante ist keine Variable. Die Konstante wird zuerst an eine lokale Variable gebunden, und diese wird indiziert.
Meldung:
Dieses Modul scheitert mit H6059:
module body Example is
constant digits: Span[Nat8, Static] := "0123456789";
function main(): ExitCode is
printLn(digits[1]);
return ExitSuccess();
end;
end module body.5. Module
H2001
Der Body definiert einen Namen des Interfaces als eine andere Art von Deklaration, etwa als Funktion, wo das Interface eine Konstante deklariert.
Meldung:
Dieses Modul scheitert mit H2001:
module body Example is
function limit(): Int32 is
return 5;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
constant limit: Int32;
function main(): ExitCode;
end module.H2002
Eine Funktion hat im Interface andere Typparameter, Parameter oder einen anderen Rückgabetyp als im Body. Die Meldung sagt, was sich unterscheidet.
Meldung:
Dieses Modul scheitert mit H2002:
module body Example is
function twice(n: Int64): Int64 is
return n * 2;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
function twice(n: Int32): Int32;
function main(): ExitCode;
end module.H2004
Das Interface deklariert etwas, das der Body nicht definiert.
Meldung:
Dieses Modul scheitert mit H2004:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
function twice(n: Int32): Int32;
function main(): ExitCode;
end module.H2005
Das Interface deklariert eine Instanz, die der Body nicht definiert.
Meldung:
Dieses Modul scheitert mit H2005:
module body Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
typeclass Describe(T: Free) is
method describe(value: T): Int32;
end;
instance Describe(Int32);
function main(): ExitCode;
end module.H2006
Interface und Body, die auf der Kommandozeile als Paar stehen, nennen verschiedene Module.
Meldung:
Dieses Modul scheitert mit H2006:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Sample is
function main(): ExitCode;
end module.H2008
Eine Deklaration hat im Interface einen anderen Typ als im Body, etwa eine Konstante.
Meldung:
Dieses Modul scheitert mit H2008:
module body Example is
constant limit: Int64 := 5;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
constant limit: Int32;
function main(): ExitCode;
end module.H2009
Ein opaker Typ ist im Interface in einem Universum deklariert und im Body in einem anderen definiert.
Meldung:
Dieses Modul scheitert mit H2009:
module body Example is
record Ticket: Linear is
number: Int32;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
type Ticket: Free;
function main(): ExitCode;
end module.H2010
Die Übersetzung wurde mit --forbid-unsafe-modules gestartet, und eines ihrer Module ist unsicher.
Meldung:
Dieses Modul scheitert mit H2010:
pragma Unsafe_Module;
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H2011
Ein Pragma bekommt die falschen Argumente. Die Meldung sagt, welches Argument es nimmt oder dass es keines nimmt.
Meldung:
Dieses Modul scheitert mit H2011:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Import(Name => "hilde_put_character");
function putCharacter(character: Nat8): Int32 is
end;
function main(): ExitCode is
putCharacter('a');
return ExitSuccess();
end;
end module body.H2012
Ein Pragma hat einen Namen, den der Compiler nicht kennt. Die Pragmas heißen Unsafe_Module, Foreign_Library, Foreign_Header, Foreign_Import und Foreign_Export.
Meldung:
Dieses Modul scheitert mit H2012:
pragma Unsafe_Modul;
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2013
Ein sicheres Modul nennt eine C-Bibliothek. Nur ein Modul mit pragma Unsafe_Module hat C, gegen das gelinkt wird.
Meldung:
Dieses Modul scheitert mit H2013:
pragma Foreign_Library(Name => "m");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2014
Der Name in pragma Foreign_Library ist leer. Er ist der Name einer Bibliothek, das z von -lz.
Meldung:
Dieses Modul scheitert mit H2014:
pragma Unsafe_Module;
pragma Foreign_Library(Name => "");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2015
Ein Modul deklariert denselben Namen zweimal.
Meldung:
Dieses Modul scheitert mit H2015:
module body Example is
function twice(n: Int32): Int32 is
return n * 2;
end;
function twice(n: Int64): Int64 is
return n * 2;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2016
Zwei Module einer Übersetzung haben denselben Namen.
Meldung:
Dieses Modul scheitert mit H2016:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Example is
function answer(): Int32;
end module.Daneben Library.hiq:
module body Example is
function answer(): Int32 is
return 42;
end;
end module body.H2017
Ein Import nennt ein Modul, das nicht zur Übersetzung gehört. Trägt ein Modul der Übersetzung einen Namen, der nur wenige Buchstaben entfernt ist, fügt die Meldung Did you mean und diesen Namen an.
Meldung:
Dieses Modul scheitert mit H2017:
import Library (answer);
module body Example is
function main(): ExitCode is
printLn(answer());
return ExitSuccess();
end;
end module body.H2018
Eine über einen Typ generische Funktion trägt pragma Foreign_Export. C kann sie nicht aufrufen, weil sie keine einzige feste Form hat. Eine exportierte Funktion darf nur über Regionen generisch sein: Eine Region übergibt zur Laufzeit nichts, und die Funktion wird einmal gebaut, für die statische Region.
Meldung:
Dieses Modul scheitert mit H2018:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Export(External_Name => "example_keep");
generic [T: Free]
function keep(value: T): T is
return value;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2027
Zwei Importe vergeben denselben lokalen Namen. Einer bekommt mit as einen anderen.
Meldung:
Dieses Modul scheitert mit H2027:
import Library (answer, question as answer);
module body Example is
function main(): ExitCode is
printLn(answer());
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
function answer(): Int32;
function question(): Int32;
end module.Daneben Library.hiq:
module body Library is
function answer(): Int32 is
return 42;
end;
function question(): Int32 is
return 6;
end;
end module body.H2028
Ein sicheres Modul importiert aus Hilde.Memory, dessen rohe Zeiger nur unsichere Module verwenden dürfen.
Meldung:
Dieses Modul scheitert mit H2028:
import Hilde.Memory (Pointer);
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2029
Ein Import nennt etwas, das sein Modul nur im Body definiert. Was das Interface nicht deklariert, ist privat.
Meldung:
Dieses Modul scheitert mit H2029:
import Library (secret);
module body Example is
function main(): ExitCode is
printLn(secret());
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
function answer(): Int32;
end module.Daneben Library.hiq:
module body Library is
function answer(): Int32 is
return secret();
end;
function secret(): Int32 is
return 42;
end;
end module body.H2030
Ein Import nennt etwas, das sein Modul gar nicht hat.
Meldung:
Dieses Modul scheitert mit H2030:
import Library (question);
module body Example is
function main(): ExitCode is
printLn(question());
return ExitSuccess();
end;
end module body.Daneben Library.hih:
module Library is
function answer(): Int32;
end module.Daneben Library.hiq:
module body Library is
function answer(): Int32 is
return 42;
end;
end module body.H2038
Ein sicheres Modul verwendet @embed, das C einfügt, das der Compiler nicht prüft. Das darf nur ein Modul mit pragma Unsafe_Module.
Meldung:
Dieses Modul scheitert mit H2038:
module body Example is
function main(): ExitCode is
let n: Int32 := @embed(Int32, "42");
printLn(n);
return ExitSuccess();
end;
end module body.H2039
Ein sicheres Modul bindet mit pragma Foreign_Import eine C-Funktion.
Meldung:
Dieses Modul scheitert mit H2039:
module body Example is
pragma Foreign_Import(External_Name => "hilde_put_character");
function putCharacter(character: Nat8): Int32 is
end;
function main(): ExitCode is
putCharacter('a');
return ExitSuccess();
end;
end module body.H2040
Eine mit Foreign_Import an C gebundene Funktion hat Typparameter. Eine C-Funktion hat eine einzige feste Signatur.
Meldung:
Dieses Modul scheitert mit H2040:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Import(External_Name => "hilde_put_character");
generic [T: Free]
function putCharacter(character: T): Int32 is
end;
function main(): ExitCode is
let c: Nat8 := 'a';
putCharacter(c);
return ExitSuccess();
end;
end module body.H2041
Vor einer Funktion steht ein anderes Pragma als Foreign_Import oder Foreign_Export. Modul-Pragmas stehen vor module body.
Meldung:
Dieses Modul scheitert mit H2041:
module body Example is
pragma Unsafe_Module;
function answer(): Int32 is
return 42;
end;
function main(): ExitCode is
printLn(answer());
return ExitSuccess();
end;
end module body.H2042
Ein sicheres Modul nennt mit pragma Foreign_Header einen C-Header.
Meldung:
Dieses Modul scheitert mit H2042:
pragma Foreign_Header(Name => "sys/utsname.h");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2043
Der Name in pragma Foreign_Header ist kein Header-Name. Er ist das, was zwischen den spitzen Klammern eines include steht: Buchstaben, Ziffern und _ . / + -, nicht mit einem Schrägstrich am Anfang und ohne einen Teil ..
Meldung:
Dieses Modul scheitert mit H2043:
pragma Unsafe_Module;
pragma Foreign_Header(Name => "../secret.h");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2044
Ein Programm importiert sowohl Standard.Sqlite als auch Standard.SqlCipher. Die beiden C-Bibliotheken exportieren dieselben Funktionen; ein Programm linkt deshalb nur eine davon.
Meldung:
Dieses Modul scheitert mit H2044:
import Standard.Sqlite (Connection);
import Standard.SqlCipher (Connection as CipherConnection);
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2045
Ein Programm importiert ein Modul, dessen Name mit Bindings. beginnt. Ein solches Modul bindet C an und ist unsafe; was seinen Aufruf sicher macht, prüft das Standard-Modul darüber, und das importiert ein Programm. Nur ein Modul, dessen Name mit Standard. oder Bindings. beginnt, darf es importieren.
Meldung:
Dieses Modul scheitert mit H2045:
import Bindings.Time (wallNanos);
module body Example is
function main(): ExitCode is
printLn(wallNanos() > 0);
return ExitSuccess();
end;
end module body.H2050
Der Name, unter dem eine Funktion exportiert wird, ist einer, den C ihr nicht geben kann: kein C-Bezeichner, ein Schlüsselwort von C oder main, ein Name, der mit hilde_ beginnt und den die Laufzeit für sich behält, oder ein Name, unter dem schon eine andere Funktion exportiert wird.
Meldung:
Dieses Modul scheitert mit H2050:
module body Example is
pragma Foreign_Export(External_Name => "hilde_keep");
function keep(value: Int32): Int32 is
return value;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2059
Eine mit Foreign_Import an C gebundene Funktion gibt Bool zurück. Eine C-Funktion gibt einen Wahrheitswert als int, der für wahr jeder Wert außer 0 sein kann, und das erzeugte C liest davon nur das unterste Byte: isalpha der glibc antwortet für einen Buchstaben 1024, dessen unterstes Byte 0 ist. Das Ergebnis von C wird als Int32 importiert und in Hilde mit /= 0 verglichen.
Meldung:
Dieses Modul scheitert mit H2059:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Import(External_Name => "isatty");
function isTerminal(descriptor: Int32): Bool is
end;
function main(): ExitCode is
let terminal: Bool := isTerminal(0);
return ExitSuccess();
end;
end module body.H2074
pragma Thread_Bound steht vor etwas, das keine Typdeklaration ist. Es markiert einen Record, eine Union oder einen opaken Typ eines Interfaces; vor einer Funktion, einer Konstante, einer Typklasse, einer Instanz oder einem Modul bedeutet es nichts.
Meldung:
Dieses Modul scheitert mit H2074:
module body Example is
pragma Thread_Bound;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3001
Eine mit Foreign_Export an C gegebene Funktion hat einen Parameter- oder Rückgabetyp, der nicht zu C hinüber kann, etwa einen Span aus etwas anderem als Nat8, einen Record mit Typparametern oder eine Referenz auf eine Zahl. Was hinüber kann und wie, steht in die Syntax beim Bau einer Bibliothek.
Meldung:
Dieses Modul scheitert mit H3001:
module body Example is
pragma Foreign_Export(External_Name => "example_sum");
generic [R: Region]
function sum(words: Span[Int32, R]): Int32 is
return 0;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6060
Die Funktion gibt es in einem anderen Modul, das die Meldung nennt, sie ist hier aber nicht importiert. Ein Interface importiert, was seine eigenen requires und ensures aufrufen: Ein Import des Modulrumpfs reicht nicht bis ins Interface.
Meldung:
Dieses Modul scheitert mit H6060:
import Other (size);
module body Example is
function count(n: Int32): Int32 is
return size(n);
end;
function main(): ExitCode is
printLn(count(3));
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
function count(n: Int32): Int32
ensures size(result) >= 0;
function main(): ExitCode;
end module.Daneben Other.hih:
module Other is
function size(n: Int32): Int32;
end module.Daneben Other.hiq:
module body Other is
function size(n: Int32): Int32 is
return n;
end;
end module body.6. Anderes
H1001
Der Wert von --entrypoint hat nicht die Form Modul:Funktion.
Meldung:
Dieses Modul scheitert mit H1001:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1002
Ein Modul auf der Kommandozeile steht weder als einzelne Body-Datei noch als Interface und Body, durch ein Komma verbunden.
Meldung:
Dieses Modul scheitert mit H1002:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1003
Das Kommando compile hat kein --entrypoint. Ein Programm braucht eines; eine C-Datei ohne Einstiegspunkt entsteht mit --target-type=c und --no-entrypoint.
Meldung:
Dieses Modul scheitert mit H1003:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1004
Das Kommando compile nennt kein Modul.
Meldung:
Dieses Modul scheitert mit H1004:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1005
Das Kommando compile hat kein --output.
Meldung:
Dieses Modul scheitert mit H1005:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1006
Der Compiler soll den Einstiegspunkt weglassen, und sein Ziel ist weder C noch eine Bibliothek. Ein Programm ohne Einstiegspunkt wird als C geschrieben oder als Bibliothek gebaut, damit ein Programm einer anderen Sprache es linken kann.
Meldung:
Dieses Modul scheitert mit H1006:
module body Example is
function answer(): Int32 is
return 42;
end;
end module body.Mit diesem Aufruf:
H1007
Der Wert von --target-type ist keiner von exe, c, tc, static und shared.
Meldung:
Dieses Modul scheitert mit H1007:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1008
Der Wert von --error-format ist keiner der Werte plain, json, hilde-json und json-lines.
Meldung:
Dieses Modul scheitert mit H1008:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1009
Ein Flag steht zweimal da.
Meldung:
Dieses Modul scheitert mit H1009:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1010
Die Argumentliste des Compilers ist leer, nicht einmal der Name des Programms steht darin. Eine Shell übergibt den Namen immer; nur ein Programm, das den Compiler ohne ihn startet, könnte diese Meldung erreichen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1011
Ein Flag ohne Wert bekommt einen, wie in --flag=wert.
Meldung:
Dieses Modul scheitert mit H1011:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1012
Ein Flag, das einen Wert nimmt, steht ohne Wert da.
Meldung:
Dieses Modul scheitert mit H1012:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1013
Ein Flag enthält mehr als ein Gleichheitszeichen und ist damit weder --flag noch --flag=wert.
Meldung:
Dieses Modul scheitert mit H1013:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1014
Der C-Compiler hat den erzeugten C-Code abgelehnt. Bei einem richtigen Programm liegt das an C, das mit @embed eingefügt wurde, an einer fehlenden C-Bibliothek oder an einem Fehler im Compiler. Die Meldung zitiert das Kommando des C-Compilers und seine Ausgabe. Bei --target-type=static läuft nach dem C-Compiler der Archivierer ar(1); scheitert er, ist der Code derselbe, und die Meldung beginnt mit Failed to run the archiver ar.
Meldung:
Dieses Modul scheitert mit H1014:
pragma Unsafe_Module;
module body Example is
function main(): ExitCode is
let n: Int32 := @embed(Int32, "this is not C");
printLn(n);
return ExitSuccess();
end;
end module body.H1015
Der Compiler konnte seine Ausgabedatei nicht öffnen oder nicht schreiben, etwa weil ihr Verzeichnis fehlt oder das Gerät voll ist.
Meldung:
Dieses Modul scheitert mit H1015:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1016
Das ist die Meldung für ein Scheitern beim Schreiben, das kein Systemfehler ist; ein Systemfehler, etwa ein fehlendes Verzeichnis, ist H1015. Es fand sich kein Weg, das Schreiben anders scheitern zu lassen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1017
hilde query fragt nach einem Modul, das nicht auf der Kommandozeile steht.
Meldung:
Dieses Modul scheitert mit H1017:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1018
hilde query wird ohne --module aufgerufen und weiß daher nicht, welches Modul es beschreiben soll.
Meldung:
Dieses Modul scheitert mit H1018:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1019
hilde test wird ohne Pfad aufgerufen und weiß daher nicht, wo es Tests suchen soll.
Meldung:
Dieses Modul scheitert mit H1019:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1020
hilde test bekommt zwei Schalter, die einander ausschließen: zwei der Instrumente --race, --memory und --valgrind, oder --emit-c neben einem von ihnen.
ThreadSanitizer und AddressSanitizer lassen sich nicht in ein Programm bauen, und valgrind führt ein Programm aus, das ohne beide gebaut ist; --emit-c schreibt C und baut nichts, ein Instrument daneben bliebe also ohne Wirkung.
Meldung:
Dieses Modul scheitert mit H1020:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1021
hilde test bekommt ein Instrument, --race, --memory oder --valgrind, das dieses System nicht ausführen kann: Sein C-Compiler baut oder startet kein Programm mit den Schaltern des Instruments, valgrind lässt sich nicht starten, oder der C-Compiler findet valgrinds Header valgrind/valgrind.h nicht.
hilde test fragt, bevor es etwas baut: Ein Programm, das nichts tut, wird mit den Schaltern übersetzt und gestartet, und valgrind wird nach seiner Version gefragt und ein Programm übersetzt, das seinen Header liest. Die Laufzeit braucht den Header unter --valgrind: Sie meldet jeden Task-Stack bei valgrind an.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1022
Ein Pfad, den hilde test bekommt, ist weder ein Verzeichnis noch eine .hiq-Datei, zum Beispiel weil es ihn nicht gibt.
Meldung:
Dieses Modul scheitert mit H1022:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1023
hilde test hat die Verzeichnisse durchsucht, die es bekam, und darin keine Testdatei gefunden.
Meldung:
Dieses Modul scheitert mit H1023:
module body Example is
function double(n: Nat32): Nat32 is
return n * 2;
end;
end module body.Mit diesem Aufruf:
H1024
Zwei Dateien unter den Pfaden von hilde test deklarieren dasselbe Modul, und eine Testdatei importiert es.
Ein Name, den zwei Dateien deklarieren, wird nur abgelehnt, wenn ein Testprogramm ihn braucht; sonst in den Verzeichnissen schadet er nicht.
Meldung:
Dieses Modul scheitert mit H1024:
module body Example is
function double(n: Nat32): Nat32 is
return n * 2;
end;
end module body.Daneben Other.hiq:
module body Example is
function double(n: Nat32): Nat32 is
return n + n;
end;
end module body.Daneben Example.test.hiq:
import Example (double);
module body Example.Test is
function testDouble(): Unit is
if double(2) /= 4 then
abort("double(2) is not 4");
end if;
return nil;
end;
end module body.Mit diesem Aufruf:
H1025
Ein Verzeichnis, in dem hilde test Module sucht, enthält ein Interface ohne den Rumpf gleichen Namens daneben.
Meldung:
Dieses Modul scheitert mit H1025:
module body Example is
function double(n: Nat32): Nat32 is
return n * 2;
end;
end module body.Daneben Other.hih:
module Other is
function half(n: Nat32): Nat32;
end module.Daneben Example.test.hiq:
import Example (double);
module body Example.Test is
function testDouble(): Unit is
if double(2) /= 4 then
abort("double(2) is not 4");
end if;
return nil;
end;
end module body.Mit diesem Aufruf:
H1026
Eine Bibliothek wird gebaut, --target-type=static, shared oder wasm, und die Kommandozeile nennt dazu einen Einstiegspunkt. Eine Bibliothek hat keinen Einstiegspunkt: C ruft die Funktionen auf, die sie exportiert, nach hilde_start.
Meldung:
Dieses Modul scheitert mit H1026:
module body Example is
pragma Foreign_Export(External_Name => "example_twice");
function twice(x: Int32): Int32 is
return x * 2;
end;
end module body.Mit diesem Aufruf:
H1027
Die Ausgabe einer Bibliothek endet nicht auf die Endung ihrer Art, .a für --target-type=static und .so für shared, oder ist nur die Endung. Der Header wird neben die Bibliothek geschrieben, unter demselben Namen mit der Endung .h, also muss der Name sagen, wo seine Endung beginnt.
Meldung:
Dieses Modul scheitert mit H1027:
module body Example is
pragma Foreign_Export(External_Name => "example_twice");
function twice(x: Int32): Int32 is
return x * 2;
end;
end module body.Mit diesem Aufruf:
H1028
hilde test --contracts bekommt einen Seed oder eine Zahl von Runden, die keine Dezimalzahl in ihrem Bereich ist.
Ein Seed ist ein Nat64, von 0 bis 18446744073709551615, weil er als solcher in das Programm geschrieben wird, das die Eingaben zieht; die Runden reichen von 1 bis 100000, weil ein Lauf ohne Runden nichts testen würde.
Meldung:
Dieses Modul scheitert mit H1028:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1029
hilde test bekommt --seed oder --rounds ohne --contracts.
Nur ein Lauf, der Verträge testet, zieht Eingaben; ohne ihn bliebe der Schalter ohne Wirkung, und ein Schalter ohne Wirkung wird abgewiesen statt übergangen.
Meldung:
Dieses Modul scheitert mit H1029:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1030
hilde guard bekommt einen Einstiegspunkt, der keine Funktion eines Moduls auf seiner Kommandozeile ist.
Der Gang über die Aufrufe des Programms beginnt beim Einstiegspunkt; ein Name, den es nicht gibt, ließe nichts, wovon er ausgehen könnte. Er wird abgewiesen, statt als fehlender Einstiegspunkt gelesen zu werden.
Meldung:
Dieses Modul scheitert mit H1030:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1031
hilde guard bekommt eine Schwachstellen-Datenbank, die es nicht lesen kann: einen Pfad, den es nicht gibt, eine Datei, die kein JSON ist, oder einen Eintrag, der nicht im OSV-Format steht.
Eine Prüfung, die ihre Datenbank nicht lesen konnte, fände nichts, und ein Bericht ohne Befund sähe aus wie ein Programm ohne Schwachstellen; deshalb wird die Datenbank vor dem Programm gelesen, und ein Fehler darin beendet das Kommando.
Meldung:
Dieses Modul scheitert mit H1031:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1032
Ein Eintrag von --library-versions ist nicht der Name einer Bibliothek, wie sie gebunden wird, ein Doppelpunkt und eine Version aus Zahlen mit Punkten dazwischen.
Die Versionen werden Zahl für Zahl mit den Bereichen der Meldungen verglichen; eine Version in anderer Form ließe sich nicht vergleichen und wird abgewiesen, statt als fehlende Version zu gelten.
Meldung:
Dieses Modul scheitert mit H1032:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1033
Ein Pfad für hilde fmt ist weder ein Verzeichnis, dessen Hilde-Quellen formatiert werden, noch eine Datei, deren Name auf .hih oder .hiq endet. Eine Datei anderer Art gilt nicht als Quelle.
Meldung:
Dieses Modul scheitert mit H1033:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1034
Eine Datei, die der Compiler bekam, ließ sich nicht öffnen oder lesen: Es gibt sie nicht, sie ist ein Verzeichnis, oder sie darf nicht gelesen werden. hilde check, hilde compile, hilde test und hilde fmt melden es so; vorher endete der Compiler mit einer Ausnahme von OCaml.
Meldung:
Dieses Modul scheitert mit H1034:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1035
Ein Wert, der mit --build-value kommt und den ein Programm mit value aus Standard.BuildInfo liest, wird name=wert geschrieben. Der Name beginnt mit einem Buchstaben und enthält Buchstaben, Ziffern, _, . und -, höchstens 64 Bytes; der Wert ist druckbares ASCII, höchstens 1024 Bytes; jeder Name kommt einmal.
Meldung:
Dieses Modul scheitert mit H1035:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1036
SOURCE_DATE_EPOCH gibt die Zeit des Baus, die builtAt aus Standard.BuildInfo liefert, damit zwei Bauten dieselben Bytes geben können. Ein Wert, der keine Zahl von Sekunden ist, beendet hilde compile, ob das Programm das Modul importiert oder nicht, wie es die Spezifikation der Variable verlangt.
Meldung:
Dieses Modul scheitert mit H1036:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1037
Das erste Wort ist kein Befehl von hilde. Bisher gab hilde seine Hilfe aus und endete mit 0, so dass ein Werkzeug, das einen Befehl aufrief, den dieser Compiler nicht hat, etwa check bei einem älteren, das für einen Erfolg hielt. Die Meldung nennt die Befehle und, für ein Wort wenige Buchstaben von einem entfernt, diesen Befehl. In diesem Katalog stehen die Befehle als der Platzhalter {...}: der Compiler nennt die, die er hat, und die Liste wechselt mit ihm.
Meldung:
Dieses Modul scheitert mit H1037:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1049
hilde test --suite nennt eine Suite, die hilde test nicht kennt. Eine Suite ist ein Test des Hilde-Baums, den sein eigenes Skript ausführt, etwa die Kohärenz-Suite, die dieselben Fälle mit mehreren Backends baut und die Ergebnisse vergleicht. Die Meldung nennt die Suiten, die es gibt.
Meldung:
Dieses Modul scheitert mit H1049:
module body Example.Test is
function testNothing(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H1050
hilde test --suite nennt eine Suite, die hier nicht laufen kann: Ihr Skript liegt nicht unter dem Arbeitsverzeichnis, oder python3 ist nicht im Pfad. Eine Suite läuft von der Wurzel des Hilde-Baums aus, wo tests/coherence/coherence.py liegt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H2046
Eine Funktion einer Testdatei trägt den Namen eines Tests und hat eine andere Form als ein Test.
Der Name macht sie zum Test: test, gefolgt von einem Großbuchstaben oder einer Ziffer. Ein Test nimmt nichts und gibt nichts zurück, oder er nimmt die Root-Fähigkeit; eine Funktion mit dem Namen eines Tests in anderer Form wird abgelehnt statt übergangen, denn ein Test, der stillschweigend nicht läuft, sieht genauso aus wie einer, der bestanden hat.
Meldung:
Dieses Modul scheitert mit H2046:
module body Example.Test is
function testLength(n: Nat32): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H2047
Eine Testdatei deklariert keine Funktion mit dem Namen eines Tests.
Meldung:
Dieses Modul scheitert mit H2047:
module body Example.Test is
function helper(): Unit is
return nil;
end;
end module body.Mit diesem Aufruf:
H2048
Ein pragma Foreign_Library nennt ein System, das der Compiler nicht kennt. Das System wird mit der Ausgabe von uname -s verglichen und deshalb so geschrieben, wie uname es schreibt, mit Großbuchstaben. Ein falsch geschriebenes System träfe nie zu, und seine Bibliothek würde nie gelinkt; deshalb wird es abgelehnt.
Meldung:
Dieses Modul scheitert mit H2048:
pragma Unsafe_Module;
pragma Foreign_Library(Name => "m", System => "linux");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2049
Ein pragma Foreign_Library hat Argumente, die es nicht kennt, oder seine beiden in der anderen Reihenfolge. Es nimmt Name und danach System, wenn die Bibliothek nur auf einem System gelinkt wird.
Meldung:
Dieses Modul scheitert mit H2049:
pragma Unsafe_Module;
pragma Foreign_Library(System => "Linux", Name => "m");
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3059
Ein literales Muster für compile aus Standard.Regex ist eines, das das Modul zur Laufzeit ablehnen würde. Ein literales Muster wird schon beim Kompilieren geprüft.
Meldung:
Dieses Modul scheitert mit H3059:
import Standard.String (String, destroyString);
import Standard.Regex (Regex, compile, destroyRegex);
module body Example is
function main(): ExitCode is
let compiled: Either[String, Regex] := compile("a(?=b)");
case compiled of
when Right(right as re: Regex) do
destroyRegex(re);
when Left(left as message: String) do
destroyString(message);
end case;
return ExitSuccess();
end;
end module body.H5001
Die Einstiegsfunktion hat mehr als einen Parameter. Sie hat keinen oder einen vom Typ RootCapability.
Meldung:
Dieses Modul scheitert mit H5001:
module body Example is
function main(root: RootCapability, n: Int32): ExitCode is
surrenderRoot(root);
return ExitSuccess();
end;
end module body.H5002
Das in --entrypoint genannte Modul hat keine Funktion dieses Namens.
Meldung:
Dieses Modul scheitert mit H5002:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H5003
Der in --entrypoint genannte Einstiegspunkt ist keine Funktion, etwa eine Konstante.
Meldung:
Dieses Modul scheitert mit H5003:
module body Example is
constant start: Int32 := 1;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H5004
Die Einstiegsfunktion ist generisch.
Meldung:
Dieses Modul scheitert mit H5004:
module body Example is
generic [T: Free]
function main(value: T): ExitCode is
return ExitSuccess();
end;
end module body.H5005
Das Modul hat ein Interface, und das Interface deklariert die Einstiegsfunktion nicht. Sie wird dort deklariert.
Meldung:
Dieses Modul scheitert mit H5005:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
end module.H5006
Der eine Parameter der Einstiegsfunktion hat nicht den Typ RootCapability.
Meldung:
Dieses Modul scheitert mit H5006:
module body Example is
function main(n: Int32): ExitCode is
return ExitSuccess();
end;
end module body.H5007
Die Einstiegsfunktion gibt kein ExitCode zurück.
Meldung:
Dieses Modul scheitert mit H5007:
module body Example is
function main(): Int32 is
return 0;
end;
end module body.H6001
Der Pfad in @bytes ist leer, absolut oder enthält einen Teil ... Ein Modul darf nur eine Datei neben sich oder darunter einbetten.
Meldung:
Dieses Modul scheitert mit H6001:
module body Example is
function main(): ExitCode is
let data: Span[Nat8, Static] := @bytes("../data.txt");
printLn(spanLength(data));
return ExitSuccess();
end;
end module body.Daneben data.txt:
HelloH6002
Die in @bytes genannte Datei lässt sich nicht lesen, etwa weil sie nicht neben dem Modul liegt.
Meldung:
Dieses Modul scheitert mit H6002:
module body Example is
function main(): ExitCode is
let data: Span[Nat8, Static] := @bytes("missing.txt");
printLn(spanLength(data));
return ExitSuccess();
end;
end module body.H6005
Die Kommandozeile enthält ein Argument, das compile oder query nicht verwendet, etwa ein unbekanntes Flag.
Meldung:
Dieses Modul scheitert mit H6005:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H6013
Ein Ausleihausdruck steht dort, wo keine Anweisung die Ausleihe fassen kann, etwa im Wert einer Konstanten.
Meldung:
Dieses Modul scheitert mit H6013:
module body Example is
constant limit: Int32 := 5;
constant view: &[Int32, Static] := &limit;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H6020
Eine Funktion bindet denselben Namen zweimal im selben Gültigkeitsbereich, etwa mit zwei let. Hilde kennt kein Verdecken; die zweite Variable bekommt einen anderen Namen.
Meldung:
Dieses Modul scheitert mit H6020:
module body Example is
function main(): ExitCode is
let n: Int32 := 1;
let n: Int32 := 2;
printLn(n);
return ExitSuccess();
end;
end module body.H6025
Zwei verschachtelte borrow-Anweisungen geben ihren Regionen denselben Namen.
Meldung:
Dieses Modul scheitert mit H6025:
module body Example is
function main(): ExitCode is
let a: Int32 := 1;
let b: Int32 := 2;
borrow ra: &[Int32, R] := &a do
borrow rb: &[Int32, R] := &b do
printLn(!ra + !rb);
end borrow;
end borrow;
return ExitSuccess();
end;
end module body.H6047
Eine Liste von Typparametern nennt denselben Parameter zweimal.
Meldung:
Dieses Modul scheitert mit H6047:
module body Example is
generic [T: Free, T: Free]
function first(a: T, b: T): T is
return a;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H9999
Ein interner Fehler: Der Compiler hat einen Zustand erreicht, den seine eigenen Prüfungen hätten ausschließen sollen. Es ist ein Fehler des Compilers, nicht des Programms. Der Weg, den dieser Eintrag zeigte, eine Einschränkung mit einer Typklasse, die nicht importiert ist, ist jetzt H3105.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
7. Templates
H7001
Der Name eines Templates ist leer.
Meldung:
Dieses Modul scheitert mit H7001:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7002
Der Pfad eines Templates ist absolut. Ein Template wird neben dem Modul oder darunter gelesen.
Meldung:
Dieses Modul scheitert mit H7002:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("/page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7003
Der Pfad eines Templates enthält einen Teil .. und verlässt damit das Verzeichnis des Moduls.
Meldung:
Dieses Modul scheitert mit H7003:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("../page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7004
Eine Template-Datei lässt sich nicht lesen, etwa weil sie nicht neben dem Modul liegt.
Meldung:
Dieses Modul scheitert mit H7004:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("missing.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7005
Ein Tag {{ oder {% wird geöffnet und nie geschlossen.
Meldung:
Dieses Modul scheitert mit H7005:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title</p>H7006
Ein Kommentar {# wird geöffnet und nie mit #} geschlossen.
Meldung:
Dieses Modul scheitert mit H7006:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{# a note</p>H7007
Ein {% raw %} wird nie mit {% endraw %} geschlossen.
Meldung:
Dieses Modul scheitert mit H7007:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{% raw %}{{ title }}</p>H7008
Im Tag {% endraw %} steht nach endraw noch etwas.
Meldung:
Dieses Modul scheitert mit H7008:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{% raw %}x{% endraw now %}</p>H7009
Eine Zahl im Template ist keine ganze Dezimalzahl, etwa 1.5.
Meldung:
Dieses Modul scheitert mit H7009:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ 1.5 }}</p>H7011
Ein String in einem Tag enthält ein Escape, das das Template nicht kennt, etwa \x. Erlaubt sind nur diese sechs: \n \t \r \\ \' \"
Meldung:
Dieses Modul scheitert mit H7011:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ "a\x" }}</p>H7013
In einem Tag steht ein Zeichen, das nicht zur Template-Sprache gehört.
Meldung:
Dieses Modul scheitert mit H7013:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title; }}</p>H7014
Dem Ausdruck in einem Tag fehlt ein nötiges Symbol, etwa eine schließende Klammer.
Meldung:
Dieses Modul scheitert mit H7014:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ (title }}</p>H7015
In einem Tag wird ein Name erwartet, und etwas anderes steht dort, etwa nach einem Punkt.
Meldung:
Dieses Modul scheitert mit H7015:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title. }}</p>H7016
In einem Tag steht ein Operator von Jinja2, der hier keine Bedeutung hat: / teilt in einen Bruch, den ein Template hier nicht hat, und ** potenziert, was nach wenigen Schritten jeden ganzzahligen Typ verlässt. // teilt in eine ganze Zahl.
Meldung:
Dieses Modul scheitert mit H7016:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ count / 2 }}</p>H7017
Die beiden Werte eines if ... else in einer Zeile werden verschieden ausgegeben: einer ist mit |safe markiert, der andere nicht. Oder ein if in einer Zeile steht in einer Bedingung, wo and und or dasselbe sagen.
Meldung:
Dieses Modul scheitert mit H7017:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title|safe if admin else "guest" }}</p>H7018
Der Operator in fragt einen Namen der Daten, einen String nach einem Teil oder einen Buffer nach einem Element, und er fragt nach einem Text in Anführungszeichen oder dem Namen eines Strings.
Meldung:
Dieses Modul scheitert mit H7018:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{% if 1 in items %}one{% endif %}</p>H7019
Die Argumente eines Filters sind nicht durch Kommas getrennt oder nicht geschlossen.
Meldung:
Dieses Modul scheitert mit H7019:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title|trim(1 2) }}</p>H7020
Ein Makro wird mit einem Schlüsselwort-Argument name=wert aufgerufen. Argumente stehen nach Position.
Meldung:
Dieses Modul scheitert mit H7020:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}<p>{{ x }}</p>{% endmacro %}{{ show(x=title) }}H7021
Die Argumente eines Makroaufrufs sind nicht durch Kommas getrennt oder nicht geschlossen.
Meldung:
Dieses Modul scheitert mit H7021:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x, y) %}<p>{{ x }}{{ y }}</p>{% endmacro %}{{ show(title title) }}H7022
Ein Makro wird über einen Punkt aufgerufen, und der Teil vor dem Punkt ist kein Name, den ein {% import ... as %} vergeben hat, oder die Datei hat kein solches Makro. Eine Methode eines Werts kann nicht aufgerufen werden.
Meldung:
Dieses Modul scheitert mit H7022:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title.upper() }}</p>H7023
In eckigen Klammern steht etwas anderes als ein Name in Anführungszeichen. Ein Index in eine Liste scheitert, wenn Jinja2 die Seite ausgibt und die Liste kürzer ist; ein kompiliertes Template erlaubt das nicht.
Meldung:
Dieses Modul scheitert mit H7023:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ items[0] }}</p>H7024
Ein Minuszeichen steht vor einem Namen. Eine negative Zahl steht mit dem Minuszeichen vor ihren Ziffern; ein Name wird von null abgezogen.
Meldung:
Dieses Modul scheitert mit H7024:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ -count }}</p>H7025
In einem Tag steht ein Symbol, wo ein Ausdruck beginnen sollte.
Meldung:
Dieses Modul scheitert mit H7025:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ ) }}</p>H7026
Ein Tag enthält keinen Ausdruck.
Meldung:
Dieses Modul scheitert mit H7026:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ }}</p>H7027
Auf einen Ausdruck in einem Tag folgt weiterer Text.
Meldung:
Dieses Modul scheitert mit H7027:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title title }}</p>H7028
Ein {% %}-Tag beginnt nicht mit einem Schlüsselwort.
Meldung:
Dieses Modul scheitert mit H7028:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{% = title %}</p>H7029
Ein {% %}-Tag verwendet ein Schlüsselwort, das diese Template-Sprache nicht kennt, etwa do.
Meldung:
Dieses Modul scheitert mit H7029:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% do title %}<p>{{ title }}</p>H7030
Ein {% include %} oder {% extends %} nimmt den Namen des Templates und nichts danach.
Meldung:
Dieses Modul scheitert mit H7030:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% include "part.jinja" "more" %}Daneben part.jinja:
<p>{{ title }}</p>H7031
Ein {% include %} oder {% extends %} bekommt einen Namen, der kein String-Literal ist. Ein erst beim Rendern gewähltes Template lässt sich nicht kompilieren.
Meldung:
Dieses Modul scheitert mit H7031:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% include title %}Daneben part.jinja:
<p>{{ title }}</p>H7032
Einem {% import %} fehlen as und ein Name, oder es verlangt mit with context den Kontext des Templates. Ein importiertes Makro sieht die Daten des Templates nicht.
Meldung:
Dieses Modul scheitert mit H7032:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% import "macros.jinja" %}<p>{{ title }}</p>Daneben macros.jinja:
{% macro show(text) %}<b>{{ text }}</b>{% endmacro %}H7033
Ein Template verwendet {% autoescape %}. Das Maskieren lässt sich nicht abschnittsweise abschalten; der eine Wert, der unmaskiert hinaus soll, bekommt |safe.
Meldung:
Dieses Modul scheitert mit H7033:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% autoescape false %}<p>{{ title }}</p>{% endautoescape %}H7034
Ein schließender oder fortsetzender Tag wie {% endif %} oder {% else %} steht ohne seinen öffnenden Tag.
Meldung:
Dieses Modul scheitert mit H7034:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>{% endif %}H7035
Auf ein {% else %} eines {% if %} folgt kein {% endif %}.
Meldung:
Dieses Modul scheitert mit H7035:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if admin %}<p>admin</p>{% else %}<p>guest</p>H7036
Ein {% if %} wird nie mit {% endif %} geschlossen.
Meldung:
Dieses Modul scheitert mit H7036:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if admin %}<p>admin</p>H7037
Ein {% for %} nennt mehr als drei Namen. Ein Name nimmt das Element; zwei oder drei entpacken ein Pair oder ein Triple aus Standard.Tuples.
Meldung:
Dieses Modul scheitert mit H7037:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for a, b, c, d in items %}{{ a }}{% endfor %}H7038
Einem {% for %} fehlt das Wort in.
Meldung:
Dieses Modul scheitert mit H7038:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item of items %}{{ item }}{% endfor %}H7039
Nach der Folge eines {% for %} steht etwas anderes als if und eine Bedingung, etwa recursive.
Meldung:
Dieses Modul scheitert mit H7039:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items recursive %}{{ item }}{% endfor %}H7040
Auf ein {% else %} eines {% for %} folgt kein {% endfor %}.
Meldung:
Dieses Modul scheitert mit H7040:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{{ item }}{% else %}<p>none</p>H7041
Ein {% for %} wird nie mit {% endfor %} geschlossen.
Meldung:
Dieses Modul scheitert mit H7041:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{{ item }}H7042
Ein Block ist als required markiert.
Meldung:
Dieses Modul scheitert mit H7042:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% block main required %}<p>{{ title }}</p>{% endblock %}H7043
Ein {% block %} hat keinen Namen oder danach etwas anderes als scoped.
Meldung:
Dieses Modul scheitert mit H7043:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% block %}<p>{{ title }}</p>{% endblock %}H7044
Ein {% block %} wird nie mit {% endblock %} geschlossen.
Meldung:
Dieses Modul scheitert mit H7044:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% block main %}<p>{{ title }}</p>H7045
Ein {% endblock %} nennt einen anderen Block als den, den es schließt.
Meldung:
Dieses Modul scheitert mit H7045:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% block main %}<p>{{ title }}</p>{% endblock side %}H7046
Der Vorgabewert eines Makroparameters ist kein Literal.
Meldung:
Dieses Modul scheitert mit H7046:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x=title) %}{{ x }}{% endmacro %}<p>{{ show() }}</p>H7047
Die Parameter eines Makros sind nicht durch Kommas getrennt.
Meldung:
Dieses Modul scheitert mit H7047:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x y) %}{{ x }}{% endmacro %}<p>{{ show(title, title) }}</p>H7048
Auf die Parameterliste eines Makros folgt weiterer Text.
Meldung:
Dieses Modul scheitert mit H7048:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) now %}{{ x }}{% endmacro %}<p>{{ show(title) }}</p>H7049
Ein {% macro %} wird nie mit {% endmacro %} geschlossen.
Meldung:
Dieses Modul scheitert mit H7049:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}H7050
Ein {% from ... import %} gibt einem importierten Makro mit as einen anderen Namen.
Meldung:
Dieses Modul scheitert mit H7050:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from "macros.jinja" import show as display %}<p>{{ display(title) }}</p>Daneben macros.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}H7051
Ein {% from ... import %} nennt etwas anderes als Makros.
Meldung:
Dieses Modul scheitert mit H7051:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from "macros.jinja" import 1 %}<p>{{ title }}</p>Daneben macros.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}H7052
Einem {% from %} fehlt der Dateiname als String oder das Wort import.
Meldung:
Dieses Modul scheitert mit H7052:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from macros import show %}<p>{{ show(title) }}</p>Daneben macros.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}H7054
Ein Makro wird zweimal mit zwei Rümpfen definiert.
Meldung:
Dieses Modul scheitert mit H7054:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}{% macro show(x) %}<b>{{ x }}</b>{% endmacro %}<p>{{ show(title) }}</p>H7055
Ein Template importiert Makros aus sich selbst.
Meldung:
Dieses Modul scheitert mit H7055:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from "macros.jinja" import show %}<p>{{ show(title) }}</p>Daneben macros.jinja:
{% from "macros.jinja" import show %}{% macro show(x) %}{{ x }}{% endmacro %}H7056
Ein {% from ... import %} nennt ein Makro, das die Datei nicht definiert.
Meldung:
Dieses Modul scheitert mit H7056:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from "macros.jinja" import display %}<p>{{ title }}</p>Daneben macros.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}H7057
Ein Template bindet sich selbst ein oder erweitert sich selbst, direkt oder über andere.
Meldung:
Dieses Modul scheitert mit H7057:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% include "part.jinja" %}Daneben part.jinja:
<p>{{ title }}</p>{% include "page.jinja" %}H7058
Ein Template erweitert ein zweites Mal.
Meldung:
Dieses Modul scheitert mit H7058:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% extends "base.jinja" %}{% block main %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7059
Nach {% extends %} steht Text außerhalb eines Blocks. Jinja2 würde ihn verwerfen; hier wird er abgelehnt.
Meldung:
Dieses Modul scheitert mit H7059:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}lost text{% block main %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7060
Nach {% extends %} steht ein Wert außerhalb eines Blocks.
Meldung:
Dieses Modul scheitert mit H7060:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{{ title }}{% block main %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7061
Nach {% extends %} steht ein {% if %} oder {% for %} außerhalb eines Blocks.
Meldung:
Dieses Modul scheitert mit H7061:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% if admin %}{% endif %}{% block main %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7062
Nach {% extends %} steht ein {% include %} außerhalb eines Blocks.
Meldung:
Dieses Modul scheitert mit H7062:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% include "part.jinja" %}{% block main %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>Daneben part.jinja:
<p>{{ title }}</p>H7063
super() steht in einem Block, den kein Template darüber hat.
Meldung:
Dieses Modul scheitert mit H7063:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% block main %}{{ super() }}<p>{{ title }}</p>{% endblock %}H7064
super() bekommt Argumente.
Meldung:
Dieses Modul scheitert mit H7064:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% block main %}{{ super(1) }}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7065
Ein {% extends %} steht in einem anderen Tag, etwa einem {% if %}. Es steht auf oberster Ebene, einmal.
Meldung:
Dieses Modul scheitert mit H7065:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if admin %}{% extends "base.jinja" %}{% endif %}<p>{{ title }}</p>Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7066
Ein Template definiert einen Block, den kein erweitertes Template hat. Jinja2 würde ihn verwerfen; hier wird er abgelehnt.
Meldung:
Dieses Modul scheitert mit H7066:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% block side %}{{ title }}{% endblock %}Daneben base.jinja:
<html>{% block main %}{% endblock %}</html>H7067
Ein Wert steht an einer Stelle des HTML, an der ihn kein Maskieren sicher macht, etwa im Namen eines Tags oder in seiner Attributliste.
Meldung:
Dieses Modul scheitert mit H7067:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<div {{ title }}>x</div>H7069
loop wird für etwas anderes als loop.index, loop.index0, loop.length, loop.first oder loop.last verwendet.
Meldung:
Dieses Modul scheitert mit H7069:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{{ loop }}{% endfor %}H7070
Ein mit {% from ... import %} geholtes Makro verwendet die Daten des Templates. Ein solches Makro sieht nur seine Argumente.
Meldung:
Dieses Modul scheitert mit H7070:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% from "macros.jinja" import show %}<p>{{ show() }}</p>Daneben macros.jinja:
{% macro show() %}{{ title }}{% endmacro %}H7071
loop wird außerhalb eines {% for %} verwendet.
Meldung:
Dieses Modul scheitert mit H7071:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ loop.index }}</p>H7072
Eine in einer Bedingung verglichene Zahl ist zu groß.
Meldung:
Dieses Modul scheitert mit H7072:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if count > 99999999999999999999 %}many{% endif %}H7073
Ein Schleifenattribut wird ausgegeben, das sich nicht ausgeben lässt.
Meldung:
Dieses Modul scheitert mit H7073:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{{ loop.cycle }}{% endfor %}H7075
|length wird auf etwas angewandt, das kein Name der Daten ist.
Meldung:
Dieses Modul scheitert mit H7075:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ "abc"|length }}</p>H7076
Es wird ein Filter verwendet, den diese Template-Sprache nicht kennt.
Meldung:
Dieses Modul scheitert mit H7076:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title|wordcount }}</p>H7077
none wird ausgegeben. Ein Option wird ausgegeben, nachdem mit is not none gefragt wurde.
Meldung:
Dieses Modul scheitert mit H7077:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ none }}</p>H7079
Ein Makroaufruf steht mit einem Filter in {{ }}. Ein Makroaufruf steht allein.
Meldung:
Dieses Modul scheitert mit H7079:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}<p>{{ show(title)|upper }}</p>H7080
Ein Attribut von loop, das keine Zahl ist, steht, wo eine Zahl hingehört, in einem Vergleich oder in einer Rechnung. loop.first und loop.last sind Bedingungen.
Meldung:
Dieses Modul scheitert mit H7080:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{% if loop.first > 0 %}{{ item }}{% endif %}{% endfor %}H7082
Eine Bedingung fragt is defined. Das Template wird gegen einen Datentyp kompiliert; jeder Name ist also beim Kompilieren bekannt.
Meldung:
Dieses Modul scheitert mit H7082:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if title is defined %}<p>{{ title }}</p>{% endif %}H7083
is none wird von etwas gefragt, das kein Name der Daten ist.
Meldung:
Dieses Modul scheitert mit H7083:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if "x" is none %}<p>none</p>{% endif %}H7084
Eine Bedingung verwendet einen Test, den diese Template-Sprache nicht kennt.
Meldung:
Dieses Modul scheitert mit H7084:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if count is even %}<p>even</p>{% endif %}H7085
Ein String wird mit einem anderen Operator als == und != verglichen.
Meldung:
Dieses Modul scheitert mit H7085:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if title < "m" %}<p>early</p>{% endif %}H7086
Ein Vergleich vergleicht nicht einen Namen mit einem Literal.
Meldung:
Dieses Modul scheitert mit H7086:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if count > count %}<p>more</p>{% endif %}H7087
Etwas, das keine Bedingung ist, steht als Bedingung, etwa ein String.
Meldung:
Dieses Modul scheitert mit H7087:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if "yes" %}<p>yes</p>{% endif %}H7088
Ein Makroparameter, der ein Literal bekommt, wird mit einem Feld verwendet, wie in x.name.
Meldung:
Dieses Modul scheitert mit H7088:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x.name }}{% endmacro %}<p>{{ show("a") }}</p>H7089
Ein Makro wird aufgerufen, das nicht definiert ist.
Meldung:
Dieses Modul scheitert mit H7089:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ show(title) }}</p>H7090
Ein Makro ruft sich selbst auf. Ein Template wird beim Kompilieren ausgeklappt, und eine Rekursion würde nicht enden.
Meldung:
Dieses Modul scheitert mit H7090:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ show(x) }}{% endmacro %}<p>{{ show(title) }}</p>H7091
Ein Makro wird mit mehr Argumenten aufgerufen, als es Parameter hat.
Meldung:
Dieses Modul scheitert mit H7091:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}<p>{{ show(title, title) }}</p>H7092
Ein Makro wird ohne Wert für einen Parameter ohne Vorgabewert aufgerufen.
Meldung:
Dieses Modul scheitert mit H7092:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}<p>{{ show() }}</p>H7093
Ein Makroargument ist weder ein Name noch ein Literal.
Meldung:
Dieses Modul scheitert mit H7093:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro show(x) %}{{ x }}{% endmacro %}<p>{{ show(title|upper) }}</p>H7095
Die Zweige eines {% if %} enden an verschiedenen Stellen des HTML, etwa einer in einem Script und einer außerhalb.
Meldung:
Dieses Modul scheitert mit H7095:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if admin %}<script>{% endif %}<p>{{ title }}</p>H7096
Ein {% for %} läuft über etwas, das kein Name der Daten ist.
Meldung:
Dieses Modul scheitert mit H7096:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for c in "abc" %}{{ c }}{% endfor %}H7097
Der Rumpf eines {% for %} endet an einer anderen Stelle des HTML, als er beginnt.
Meldung:
Dieses Modul scheitert mit H7097:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}<script>{% endfor %}H7098
Das {% else %} eines {% for %} endet an einer anderen Stelle des HTML, als es beginnt.
Meldung:
Dieses Modul scheitert mit H7098:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% for item in items %}{{ item }}{% else %}<script>{% endfor %}H7099
Ein Modul, das @template verwendet, importiert Standard.Template nicht. Der erzeugte Code ruft es auf, und seine Instanzen kommen mit dem Import.
Meldung:
Dieses Modul scheitert mit H7099:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7100
Ein {% set %}-Block, ein {% with %}, ein {% filter %} oder ein {% call %} wird nicht mit seinem End-Tag geschlossen.
Meldung:
Dieses Modul scheitert mit H7100:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% with name = title %}<p>{{ name }}</p>H7101
Das Tag eines {% set %}, {% with %}, {% filter %} oder {% call %} hat nicht seine Form: set nimmt einen Namen, = und einen Wert; with nimmt Namen mit = und Werten, durch Kommas getrennt; filter nimmt Filter, durch | getrennt; call nimmt einen Makroaufruf, und caller() nimmt keine Parameter.
Meldung:
Dieses Modul scheitert mit H7101:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% set a b = title %}<p>{{ a }}</p>H7102
Der Name, den ein {% import ... as %} vergeben hat, wird ausgegeben oder zwei Imports gegeben. Er steht für die Makros einer Datei und verdeckt ein gleichnamiges Feld der Daten, wie in Jinja2.
Meldung:
Dieses Modul scheitert mit H7102:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% import "macros.jinja" as lib %}<p>{{ lib }}</p>Daneben macros.jinja:
{% macro show(text) %}<b>{{ text }}</b>{% endmacro %}H7103
Ein {% set %} steht nach {% extends %} und außerhalb jedes Blocks. Ob ein Block der Elternvorlage den Namen sieht, hängt von der Reihenfolge ab, in der Jinja2 die beiden Templates ausführt; er gehört in den Block.
Meldung:
Dieses Modul scheitert mit H7103:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% extends "base.jinja" %}{% set name = title %}{% block main %}{{ name }}{% endblock %}Daneben base.jinja:
<main>{% block main %}{% endblock %}</main>H7104
Ein Name, den ein {% set %} oder ein {% with %} an einen berechneten Wert gebunden hat, etwa einen mit ~ verbundenen Text, wird nach einem Feld gefragt. Nur ein Name der Daten hat Felder.
Meldung:
Dieses Modul scheitert mit H7104:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% set name = title ~ "!" %}<p>{{ name.length }}</p>H7105
// oder % teilt durch einen Namen der Daten oder durch null. Ein Teiler aus den Daten könnte null sein, und eine Division durch null hält das Programm an; der Teiler ist eine im Template geschriebene Zahl.
Meldung:
Dieses Modul scheitert mit H7105:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ count // count }}</p>H7106
Ein Operand von + - * // % ist etwas anderes als eine Zahl: ein Text, ein Filter oder eine Bedingung.
Meldung:
Dieses Modul scheitert mit H7106:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ count + "1" }}</p>H7107
Der Operator ~ verbindet einen mit |safe markierten Wert oder den Text eines {% set %}-Blocks mit einem Text, der bei der Ausgabe maskiert wird. Das Ergebnis wäre halb maskiert; der Wert mit |safe wird für sich ausgegeben.
Meldung:
Dieses Modul scheitert mit H7107:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title|safe ~ "!" }}</p>H7108
Die Argumente von |replace, |truncate, |center, |join oder loop.cycle sind keine Literale der Art, die der Filter nimmt, oder nicht in ihrem Bereich: die Länge von |truncate ist mindestens die Länge ihres Endes.
Meldung:
Dieses Modul scheitert mit H7108:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title|truncate(2) }}</p>H7109
Ein {% filter %}-Block nennt einen Filter, der auf einen Wert wirkt, etwa |join oder |length, nicht auf den Text, den der Block schreibt.
Meldung:
Dieses Modul scheitert mit H7109:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% filter join %}<p>{{ title }}</p>{% endfilter %}H7110
Ein {% set %} steht in einem {% if %}. In Jinja2 ist der Name nach dem {% endif %} noch da, wenn der Zweig lief, und fehlt, wenn nicht; ein kompiliertes Template kann dem nicht folgen. Der Name gehört vor das {% if %}, oder es steht ein {% with %}.
Meldung:
Dieses Modul scheitert mit H7110:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% if admin %}{% set name = title %}{% endif %}<p>{{ title }}</p>H7111
Ein {% filter %}-Block steht an einer anderen Stelle als im HTML-Text, oder der Text eines {% set %}- oder {% filter %}-Blocks endet an einer anderen Stelle, als er begann. Was ein solcher Block schreibt, wird als HTML-Text maskiert.
Meldung:
Dieses Modul scheitert mit H7111:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<a title="{% filter upper %}{{ title }}{% endfilter %}">x</a>H7112
caller() steht in einem Makro, das ohne {% call %}-Block aufgerufen wird, oder bekommt Argumente. Jinja2 scheitert, wenn es einen solchen Aufruf ausgibt.
Meldung:
Dieses Modul scheitert mit H7112:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% macro box() %}<div>{{ caller() }}</div>{% endmacro %}<p>{{ box() }}</p>H7113
Der Text, den ein {% set %}-Block geschrieben hat, wird an einer anderen Stelle als im HTML-Text ausgegeben, etwa in einem Attribut. Er ist HTML, bereits maskiert, und wird ausgegeben, wie er steht.
Meldung:
Dieses Modul scheitert mit H7113:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% set cell %}<b>{{ title }}</b>{% endset %}<a title="{{ cell }}">x</a>H7114
Das vierte Argument von @template nennt eine andere Option als trim_blocks und lstrip_blocks.
Meldung:
Dieses Modul scheitert mit H7114:
import Standard.Buffer (Buffer);
import Standard.String (String);
import Standard.StringBuilder (StringBuilder, makeStringBuilder, finalize);
import Standard.Template (Render);
module body Example is
record Page: Linear is
title: String;
motto: Option[String];
items: Buffer[Index];
admin: Bool;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out, "strict");
return finalize(out);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ title }}</p>H7115
Das erste Argument von _( ) ist der Schlüssel, geschrieben als String-Literal: der Name eines Falls der Schlüssel des Katalogs. Ein Name der Daten oder ein Ausdruck an seiner Stelle wäre ein Schlüssel, der erst beim Rendern feststeht, und den kann der Compiler nicht prüfen.
Meldung:
Dieses Modul scheitert mit H7115:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{{ _(user) }}</p>H7116
Jedes Argument von _( ) hat einen eigenen Namen; derselbe Name zweimal ließe offen, welchen Wert der Platzhalter bekommt.
Meldung:
Dieses Modul scheitert mit H7116:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{{ _("Greeting", name=user, name=user) }}</p>H7117
{% catalog %} nimmt den Namen einer Funktion ohne Argumente, die den Katalog liefert, ohne Anführungszeichen; das Modul mit dem @template hat die Funktion oder importiert sie.
Meldung:
Dieses Modul scheitert mit H7117:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog "messages" %}<p>{{ _("Greeting", name=user) }}</p>H7118
Der Text zwischen {% trans %} und {% pluralize %} oder {% endtrans %} ist der Schlüssel, ein Name wie Greeting. Die Texte der Sprachen stehen im Katalog, nicht im Template.
Meldung:
Dieses Modul scheitert mit H7118:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{% trans name=user %}Hello, {{ name }}!{% endtrans %}</p>H7119
Die Anzahl wählt die Pluralform, also nennt ein {% trans %}-Block mit {% pluralize %} sie: count=... in seinem Tag.
Meldung:
Dieses Modul scheitert mit H7119:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{% trans %}Items{% pluralize %}{% endtrans %}</p>H7120
In Jinja2 ist der Text nach {% pluralize %} die Pluralform. Hier stehen die Formen jeder Sprache im Katalog, deshalb darf dort nichts stehen.
Meldung:
Dieses Modul scheitert mit H7120:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{% trans count=count %}Items{% pluralize %}{{ count }} items{% endtrans %}</p>H7121
Ein Template nimmt seine Übersetzungen aus einem Katalog, einmal genannt mit {% catalog %}.
Meldung:
Dieses Modul scheitert mit H7121:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}{% catalog messages %}<p>{{ _("Greeting", name=user) }}</p>H7122
Eine Übersetzung braucht den Katalog, aus dem sie kommt: {% catalog name %} steht vor dem ersten _( ) oder {% trans %} des Templates.
Meldung:
Dieses Modul scheitert mit H7122:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
<p>{{ _("Greeting", name=user) }}</p>H7123
Eine Übersetzung ist Text für HTML, maskiert für die Stelle, an der sie landet, und kann nicht dort stehen, wo ein JavaScript-Ausdruck hingehört.
Meldung:
Dieses Modul scheitert mit H7123:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<script>var t = {{ _("Greeting", name=user) }};</script>H7124
Eine Übersetzung steht allein in {{ }} oder als {% trans %}-Block; ein Filter oder ein ~ würde einen Text ändern, der nur im Katalog für jede Sprache derselbe ist.
Meldung:
Dieses Modul scheitert mit H7124:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{{ _("Greeting", name=user)|upper }}</p>H7125
Nach dem Schlüssel nimmt _( ) seine Argumente als name=Wert: der Name ist der Platzhalter {name} des Textes, den er füllt.
Meldung:
Dieses Modul scheitert mit H7125:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{{ _("Greeting", user) }}</p>H7126
Jedes Argument im Tag von {% trans %} hat einen eigenen Namen.
Meldung:
Dieses Modul scheitert mit H7126:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{% trans name=user, name=user %}Greeting{% endtrans %}</p>H7127
Der Code, zu dem eine Übersetzung wird, ruft Standard.I18n auf, deshalb importiert das Modul mit dem @template es, so wie es Standard.Template importiert.
Meldung:
Dieses Modul scheitert mit H7127:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben page.jinja:
{% catalog messages %}<p>{{ _("Greeting", name=user) }}</p>H7128
In einem Template, das ein anderes erweitert, bleiben nur die Blöcke. {% catalog %} steht im erweiterten Template, vor den Blöcken, für die es gilt.
Meldung:
Dieses Modul scheitert mit H7128:
import Standard.String (
String,
fromLiteral,
destroyString
);
import Standard.StringBuilder (
StringBuilder,
makeStringBuilder,
finalize
);
import Standard.Template (
Render
);
import Standard.I18n (
Message,
Text,
Plural,
Language,
Catalog,
englishPlural,
germanPlural
);
module body Example is
union Key: Free is
case Greeting;
case Items;
end;
function english(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hello, {name}!");
when Items do
return Plural(one => "{count} item", other => "{count} items");
end case;
end;
function german(key: Key): Message is
case key of
when Greeting do
return Text(text => "Hallo, {name}!");
when Items do
return Plural(one => "{count} Teil", other => "{count} Teile");
end case;
end;
function others(i: Index): Option[Language[Key]] is
if i = 0 then
return Some(value => Language(code => "de", texts => german, plural => germanPlural));
end if;
return None();
end;
function messages(): Catalog[Key] is
return Catalog(default => Language(code => "en", texts => english, plural => englishPlural), others => others);
end;
record Page: Linear is
lang: String;
user: String;
count: Int32;
end;
generic [R: Region]
function render(page: &[Page, R]): String is
var out: StringBuilder := makeStringBuilder();
@template("page.jinja", page, out);
return finalize(out);
end;
function main(): ExitCode is
let page: Page := Page(lang => fromLiteral("de"), user => fromLiteral("Ada"), count => 2);
let text: String := render(&page);
destroyString(text);
let { lang: String, user: String, count: Int32 } := page;
destroyString(lang);
destroyString(user);
return ExitSuccess();
end;
end module body.Daneben base.jinja:
<main>{% block main %}{% endblock %}</main>Daneben page.jinja:
{% extends "base.jinja" %}{% catalog messages %}{% block main %}{{ _("Greeting", name=user) }}{% endblock %}8. SQL
H8001
Ein String oder ein in Anführungszeichen gesetzter Name im SQL wird nicht geschlossen.
Meldung:
Dieses Modul scheitert mit H8001:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE name = 'ann") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8002
Ein Kommentar /* im SQL wird nicht mit */ geschlossen.
Meldung:
Dieses Modul scheitert mit H8002:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users /* everyone") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8003
Ein Blob-Literal x'...' enthält keine gerade Anzahl hexadezimaler Ziffern.
Meldung:
Dieses Modul scheitert mit H8003:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "DELETE FROM notes WHERE body = x'ABC'");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8004
Eine Zahl geht ohne Trennung in einen Namen über, wie in 18years.
Meldung:
Dieses Modul scheitert mit H8004:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > 18years") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8005
Ein Name steht in Backticks oder eckigen Klammern. Man setzt ihn in doppelte Anführungszeichen.
Meldung:
Dieses Modul scheitert mit H8005:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT [name] FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8006
Im SQL steht ein nummerierter Parameter wie ?1. Man schreibt ? und gibt die Werte der Reihe nach an.
Meldung:
Dieses Modul scheitert mit H8006:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > ?1", 18) for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8007
Im SQL steht ein benannter Parameter wie :age. Man schreibt ? und gibt die Werte der Reihe nach an.
Meldung:
Dieses Modul scheitert mit H8007:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > :age", 18) for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8008
Im SQL steht ein Zeichen, das der Compiler nicht als SQL liest, etwa #.
Meldung:
Dieses Modul scheitert mit H8008:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age >= 18 # adults") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8009
Ein Schlüsselwort fehlt, wo die Grammatik es verlangt, etwa BY nach ORDER.
Meldung:
Dieses Modul scheitert mit H8009:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users ORDER name") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8010
Ein Symbol fehlt, wo die Grammatik es verlangt, etwa die Klammer nach IN.
Meldung:
Dieses Modul scheitert mit H8010:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age IN 18, 21") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8011
Ein Name fehlt, wo die Grammatik einen verlangt, etwa die Tabelle nach FROM.
Meldung:
Dieses Modul scheitert mit H8011:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM WHERE age > 18") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8012
Das SQL verwendet etwas, das SQLite kennt und dieser Compiler nicht annimmt, weil er ihm keinen Typ geben könnte, etwa eine Unterabfrage.
Meldung:
Dieses Modul scheitert mit H8012:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > (SELECT avg(age) FROM users)") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8013
Eine andere Funktion als count bekommt *.
Meldung:
Dieses Modul scheitert mit H8013:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Tally: Free is
total: Int64;
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT sum(*) AS total FROM users") for row: Tally do
printLn(row.total);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8014
Eine Spalte des Ergebnisses wird ohne AS benannt.
Meldung:
Dieses Modul scheitert mit H8014:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT upper(name) name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8015
Auf OR in INSERT OR oder UPDATE OR folgt etwas anderes als ABORT, FAIL, IGNORE, REPLACE oder ROLLBACK.
Meldung:
Dieses Modul scheitert mit H8015:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT OR SKIP INTO users (name) VALUES (?)", "ann");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8016
Der Vorgabewert einer Spalte in einer Migration ist kein Literal, keine Zahl mit Vorzeichen, kein CURRENT_TIME, CURRENT_DATE oder CURRENT_TIMESTAMP und kein Ausdruck in Klammern.
Meldung:
Dieses Modul scheitert mit H8016:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
created TEXT NOT NULL DEFAULT now
) STRICT;H8017
Ein Spaltentyp in einer Migration hat eine Größe, wie in VARCHAR(40). Eine STRICT-Tabelle kennt INT, INTEGER, REAL, TEXT und BLOB, ohne Größe.
Meldung:
Dieses Modul scheitert mit H8017:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name VARCHAR(40) NOT NULL
) STRICT;H8018
Nach CONSTRAINT und seinem Namen ist eine Tabellen-Constraint weder PRIMARY KEY noch UNIQUE, CHECK oder FOREIGN KEY.
Meldung:
Dieses Modul scheitert mit H8018:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER,
name TEXT NOT NULL,
CONSTRAINT users_key KEY (id)
) STRICT;H8019
Auf WITHOUT nach einer Tabelle folgt nicht ROWID.
Meldung:
Dieses Modul scheitert mit H8019:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT, WITHOUT ROWS;H8020
In der Liste der Tabellenoptionen steht nach einem Komma etwas anderes als STRICT oder WITHOUT ROWID.
Meldung:
Dieses Modul scheitert mit H8020:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT, WITHOUT_ROWID;H8021
Bei CREATE INDEX fehlt nach der Tabelle die Klammer mit den Spalten.
Meldung:
Dieses Modul scheitert mit H8021:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE INDEX users_name ON users name;H8022
Auf ALTER TABLE folgt etwas anderes als RENAME, ADD oder DROP.
Meldung:
Dieses Modul scheitert mit H8022:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
ALTER TABLE users MODIFY name TEXT;H8023
Eine Migration legt etwas anderes als eine Tabelle oder einen Index an, etwa eine View.
Meldung:
Dieses Modul scheitert mit H8023:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE VIEW names AS SELECT name FROM users;H8024
Eine Migration löscht etwas anderes als eine Tabelle oder einen Index, etwa eine View.
Meldung:
Dieses Modul scheitert mit H8024:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
DROP VIEW names;H8025
Eine Migration enthält eine andere Anweisung als CREATE TABLE, CREATE INDEX, ALTER TABLE, DROP TABLE, DROP INDEX, INSERT, UPDATE und DELETE, etwa PRAGMA.
Meldung:
Dieses Modul scheitert mit H8025:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
PRAGMA foreign_keys = ON;
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;H8026
Eine Abfrage ist weder SELECT noch INSERT, UPDATE oder DELETE. Eine Tabelle wird in einer Migration angelegt.
Meldung:
Dieses Modul scheitert mit H8026:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "CREATE TABLE tags (id INTEGER PRIMARY KEY, label TEXT NOT NULL) STRICT");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8027
Das SQL nennt eine Tabelle, die die Migrationen nicht anlegen.
Meldung:
Dieses Modul scheitert mit H8027:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM user") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8028
Das SQL nennt eine Spalte, die die Tabelle nicht hat.
Meldung:
Dieses Modul scheitert mit H8028:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "UPDATE users SET years = ? WHERE id = ?", 41, 1);
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8029
Ein Parameter steht, wo sich sein Typ nicht bestimmen lässt, etwa in ORDER BY. Ein Parameter bekommt seinen Typ von einer Spalte, mit der er verglichen oder in die er geschrieben wird.
Meldung:
Dieses Modul scheitert mit H8029:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users ORDER BY ?", "name") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8030
Eine Spalte wird mit einer Tabelle oder einem Alias qualifiziert, die die Abfrage nicht hat.
Meldung:
Dieses Modul scheitert mit H8030:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT u.name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8032
Eine Abfrage nennt eine Spalte und hat kein FROM, aus dem sie sie nehmen könnte.
Meldung:
Dieses Modul scheitert mit H8032:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8033
Keine Tabelle der Abfrage hat eine Spalte dieses Namens.
Meldung:
Dieses Modul scheitert mit H8033:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE mail IS NULL") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8034
Mehr als eine Tabelle der Abfrage hat eine Spalte dieses Namens. Man stellt den Namen der Tabelle davor.
Meldung:
Dieses Modul scheitert mit H8034:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users JOIN notes ON user_id = id") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8035
Ein Vorzeichen steht vor etwas, das keine Zahl ist.
Meldung:
Dieses Modul scheitert mit H8035:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users ORDER BY -name") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8036
NOT steht vor etwas, das keine Bedingung ist.
Meldung:
Dieses Modul scheitert mit H8036:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE NOT email") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8037
% nimmt zwei INTEGER und bekommt ein REAL.
Meldung:
Dieses Modul scheitert mit H8037:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE score % 2 = 0") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8038
Es wird mit etwas gerechnet, das keine Zahl ist.
Meldung:
Dieses Modul scheitert mit H8038:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age + '1' > 18") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8039
|| verbindet etwas, das kein TEXT ist.
Meldung:
Dieses Modul scheitert mit H8039:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name || age AS name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8040
Ein Wert wird mit = oder einem ähnlichen Operator mit NULL verglichen. Ein solcher Vergleich ist nie wahr; man schreibt IS NULL oder IS NOT NULL.
Meldung:
Dieses Modul scheitert mit H8040:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE email = NULL") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8041
Zwei Werte verschiedenen Typs werden verglichen, etwa TEXT mit INTEGER. SQLite vergleicht sie, ohne umzuwandeln, und die Antwort hängt nie von den Werten ab.
Meldung:
Dieses Modul scheitert mit H8041:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE name = 5") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8042
IS vergleicht zwei Werte verschiedenen Typs, die nie gleich sein können.
Meldung:
Dieses Modul scheitert mit H8042:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE name IS 5") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8043
Ein Parameter wird auf NULL geprüft. Sein Wert ist dort bekannt, wo er übergeben wird, im Programm.
Meldung:
Dieses Modul scheitert mit H8043:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE ? IS NULL", "ann") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8044
LIKE oder GLOB bekommt etwas, das kein TEXT ist.
Meldung:
Dieses Modul scheitert mit H8044:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age LIKE '3%'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8045
Ein Parameter steht links von IN. Dort steht eine Spalte.
Meldung:
Dieses Modul scheitert mit H8045:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE ? IN (name, email)", "ann") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8046
NULL steht links von IN. Das ist nie wahr.
Meldung:
Dieses Modul scheitert mit H8046:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE NULL IN (email, name)") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8047
NULL steht in der Liste von IN. Es trifft nie zu.
Meldung:
Dieses Modul scheitert mit H8047:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE email IN ('[email protected]', NULL)") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8048
Ein Wert in der Liste von IN hat einen anderen Typ als der Wert links, die beiden können also nie gleich sein.
Meldung:
Dieses Modul scheitert mit H8048:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age IN ('18', '21')") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8049
Ein Parameter steht links von BETWEEN. Dort steht eine Spalte.
Meldung:
Dieses Modul scheitert mit H8049:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE ? BETWEEN age AND 99", 18) for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8050
NULL steht links von BETWEEN. Das ist nie wahr.
Meldung:
Dieses Modul scheitert mit H8050:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE NULL BETWEEN 1 AND 2") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8051
Eine Grenze von BETWEEN hat einen anderen Typ als der Wert, mit dem sie verglichen wird.
Meldung:
Dieses Modul scheitert mit H8051:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age BETWEEN '18' AND '65'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8052
AND oder OR verbindet etwas, das keine Bedingung ist.
Meldung:
Dieses Modul scheitert mit H8052:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > 18 AND email") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8053
count(*) steht außerhalb der Spalten, von HAVING und ORDER BY, etwa in WHERE.
Meldung:
Dieses Modul scheitert mit H8053:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE count(*) > 1") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8054
Eine Aggregatfunktion steht außerhalb der Spalten, von HAVING und ORDER BY, etwa in WHERE.
Meldung:
Dieses Modul scheitert mit H8054:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE max(age) > 50") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8055
DISTINCT steht in einer Funktion, die keine Aggregatfunktion ist.
Meldung:
Dieses Modul scheitert mit H8055:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT upper(DISTINCT name) AS name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8056
Eine Funktion, die hier ein Argument nimmt, bekommt eine andere Anzahl.
Meldung:
Dieses Modul scheitert mit H8056:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Tally: Free is
total: Int64;
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT count(name, email) AS total FROM users") for row: Tally do
printLn(row.total);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8057
Eine Funktion, die eine Zahl nimmt, etwa abs oder sum, bekommt etwas anderes.
Meldung:
Dieses Modul scheitert mit H8057:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE abs(name) > 1") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8058
count bekommt einen Parameter.
Meldung:
Dieses Modul scheitert mit H8058:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Tally: Free is
total: Int64;
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT count(?) AS total FROM users", "x") for row: Tally do
printLn(row.total);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8059
min oder max bekommt einen Parameter.
Meldung:
Dieses Modul scheitert mit H8059:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users GROUP BY name HAVING max(?) > 1", 1) for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8060
min oder max bekommt NULL.
Meldung:
Dieses Modul scheitert mit H8060:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users GROUP BY name HAVING max(NULL) > 1") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8061
coalesce bekommt weniger als zwei Argumente oder ifnull nicht genau zwei.
Meldung:
Dieses Modul scheitert mit H8061:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE ifnull(email) = 'x'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8062
coalesce oder ifnull bekommt nur Parameter; sein Typ lässt sich daher nicht bestimmen.
Meldung:
Dieses Modul scheitert mit H8062:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE email = coalesce(?, ?)", "a", "b") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8063
Der erste Wert von coalesce oder ifnull, der kein Parameter ist, ist NULL.
Meldung:
Dieses Modul scheitert mit H8063:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE coalesce(NULL, email) = 'x'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8064
coalesce oder ifnull bekommt Werte verschiedenen Typs.
Meldung:
Dieses Modul scheitert mit H8064:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE coalesce(email, 0) = 'x'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8065
length bekommt etwas anderes als TEXT oder BLOB.
Meldung:
Dieses Modul scheitert mit H8065:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE length(age) > 1") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8066
lower oder upper bekommt etwas anderes als TEXT.
Meldung:
Dieses Modul scheitert mit H8066:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE upper(age) = 'X'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8067
Das SQL ruft eine Funktion auf, deren Typ der Compiler nicht kennt. Er kennt count, sum, total, avg, min, max, coalesce, ifnull, length, lower, upper und abs.
Meldung:
Dieses Modul scheitert mit H8067:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE trim(name) = 'x'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8068
Zwei Parameter treffen an einem Operator aufeinander, und keiner gibt dem anderen einen Typ.
Meldung:
Dieses Modul scheitert mit H8068:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE ? = ?", "a", "b") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8069
Ein WHERE, ON, HAVING oder CHECK bekommt etwas, das keine Bedingung ist.
Meldung:
Dieses Modul scheitert mit H8069:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE email") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8070
Eine Spalte des Ergebnisses hat einen Namen, der kein Feld des Zeilen-Records benennen kann, etwa einen Namen mit Leerzeichen oder ein Hilde-Schlüsselwort.
Meldung:
Dieses Modul scheitert mit H8070:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Shout[R: Region]: Free is
shout: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT upper(name) AS \"loud name\" FROM users") for row: Shout[Q] do
printLn(row.shout);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8071
* steht in einer Abfrage ohne Tabelle.
Meldung:
Dieses Modul scheitert mit H8071:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record User[R: Region]: Free is
id: Int64;
name: Span[Nat8, R];
age: Int64;
email: Option[Span[Nat8, R]];
score: Option[Float64];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT *") for row: User[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8072
t.* nennt eine Tabelle oder einen Alias, die die Abfrage nicht hat.
Meldung:
Dieses Modul scheitert mit H8072:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record User[R: Region]: Free is
id: Int64;
name: Span[Nat8, R];
age: Int64;
email: Option[Span[Nat8, R]];
score: Option[Float64];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT u.* FROM users") for row: User[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8073
Eine Spalte des Ergebnisses ist immer NULL und hat deshalb keinen Typ.
Meldung:
Dieses Modul scheitert mit H8073:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name, NULL AS note FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8074
Eine Spalte des Ergebnisses, die keine einfache Spalte ist, hat keinen Namen. Man gibt ihr einen mit AS.
Meldung:
Dieses Modul scheitert mit H8074:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT upper(name) FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8075
Zwei Spalten des Ergebnisses haben denselben Namen.
Meldung:
Dieses Modul scheitert mit H8075:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name, lower(name) AS name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8076
NULL wird in eine Spalte geschrieben, die NOT NULL ist.
Meldung:
Dieses Modul scheitert mit H8076:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (name) VALUES (NULL)");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8077
Ein Wert eines anderen Typs wird in eine Spalte geschrieben. Eine STRICT-Tabelle lehnt ihn beim Lauf des Programms ab.
Meldung:
Dieses Modul scheitert mit H8077:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (name, age) VALUES (?, '40')", "ann");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8078
Ein Wert, der NULL sein kann, wird in eine Spalte geschrieben, die NOT NULL ist.
Meldung:
Dieses Modul scheitert mit H8078:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "UPDATE users SET name = email");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8079
Eine Tabelle steht zweimal in FROM, ohne einen Alias, der die beiden unterscheidet.
Meldung:
Dieses Modul scheitert mit H8079:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users JOIN users ON age = age") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8081
LIMIT oder OFFSET bekommt etwas anderes als ein INTEGER, das nicht NULL ist.
Meldung:
Dieses Modul scheitert mit H8081:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users LIMIT '10'") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8082
Die Spaltenliste eines INSERT nennt eine Spalte zweimal.
Meldung:
Dieses Modul scheitert mit H8082:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (name, name) VALUES (?, ?)", "ann", "bob");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8083
Ein INSERT lässt eine Spalte aus, die NOT NULL ist und keinen Vorgabewert hat.
Meldung:
Dieses Modul scheitert mit H8083:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (age) VALUES (?)", 40);
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8084
Ein INSERT hat eine Spaltenliste und DEFAULT VALUES.
Meldung:
Dieses Modul scheitert mit H8084:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (name) DEFAULT VALUES");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8085
Eine Zeile eines INSERT hat eine andere Anzahl Werte, als es Spalten gibt.
Meldung:
Dieses Modul scheitert mit H8085:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "INSERT INTO users (name, age) VALUES (?)", "ann");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8086
Eine Spalte in einer Migration hat den Typ ANY. Der Compiler prüft eine Abfrage gegen eine Spalte mit INT, INTEGER, REAL, TEXT oder BLOB.
Meldung:
Dieses Modul scheitert mit H8086:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
extra ANY
) STRICT;H8087
Eine Spalte in einer Migration hat keinen Typ. Eine STRICT-Tabelle gibt jeder Spalte einen.
Meldung:
Dieses Modul scheitert mit H8087:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
nickname
) STRICT;H8088
Eine Spalte in einer Migration hat einen Typ, den eine STRICT-Tabelle nicht kennt, etwa DATE.
Meldung:
Dieses Modul scheitert mit H8088:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
born DATE
) STRICT;H8089
Eine Migration legt eine Tabelle an, die es schon gibt.
Meldung:
Dieses Modul scheitert mit H8089:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
email TEXT
) STRICT;H8090
Eine Tabelle wird ohne STRICT angelegt. Ohne STRICT speichert SQLite einen Wert jedes Typs in jeder Spalte, und die Typen, die der Compiler prüft, würden nicht gelten.
Meldung:
Dieses Modul scheitert mit H8090:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
);H8091
Eine Tabelle definiert eine Spalte zweimal.
Meldung:
Dieses Modul scheitert mit H8091:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
name TEXT
) STRICT;H8092
Eine Tabelle hat mehr als einen PRIMARY KEY.
Meldung:
Dieses Modul scheitert mit H8092:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL PRIMARY KEY
) STRICT;H8093
Der PRIMARY KEY einer Tabelle nennt eine Spalte, die die Tabelle nicht hat.
Meldung:
Dieses Modul scheitert mit H8093:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER,
name TEXT NOT NULL,
PRIMARY KEY (user_id)
) STRICT;H8094
ALTER TABLE ADD COLUMN fügt eine Spalte hinzu, die die Tabelle schon hat.
Meldung:
Dieses Modul scheitert mit H8094:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
ALTER TABLE users ADD COLUMN name TEXT;H8095
ALTER TABLE ADD COLUMN fügt einen PRIMARY KEY hinzu. SQLite kann einer bestehenden Tabelle keinen hinzufügen.
Meldung:
Dieses Modul scheitert mit H8095:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
ALTER TABLE users ADD COLUMN code INTEGER PRIMARY KEY;H8096
ALTER TABLE ADD COLUMN fügt eine NOT-NULL-Spalte ohne Vorgabewert hinzu. SQLite lehnt eine solche Spalte bei einer Tabelle mit Zeilen ab.
Meldung:
Dieses Modul scheitert mit H8096:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
ALTER TABLE users ADD COLUMN city TEXT NOT NULL;H8097
ALTER TABLE RENAME TO gibt einer Tabelle den Namen einer Tabelle, die es gibt.
Meldung:
Dieses Modul scheitert mit H8097:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE TABLE people (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
ALTER TABLE people RENAME TO users;H8098
ALTER TABLE RENAME COLUMN gibt einer Spalte den Namen einer Spalte, die die Tabelle hat.
Meldung:
Dieses Modul scheitert mit H8098:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
email TEXT
) STRICT;
ALTER TABLE users RENAME COLUMN email TO name;H8099
ALTER TABLE DROP COLUMN löscht die letzte Spalte einer Tabelle. Stattdessen löscht man die Tabelle.
Meldung:
Dieses Modul scheitert mit H8099:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE TABLE tags (label TEXT) STRICT;
ALTER TABLE tags DROP COLUMN label;H8100
DROP TABLE löscht eine Tabelle, die es nicht gibt.
Meldung:
Dieses Modul scheitert mit H8100:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
DROP TABLE tags;H8101
CREATE INDEX legt einen Index an, dessen Name schon vergeben ist.
Meldung:
Dieses Modul scheitert mit H8101:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
CREATE INDEX users_key ON users (name);
CREATE INDEX users_key ON users (id, name);H8102
DROP INDEX löscht einen Index, den es nicht gibt.
Meldung:
Dieses Modul scheitert mit H8102:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
DROP INDEX users_name;H8103
Eine Migrationsdatei lässt sich nicht lesen, etwa weil ein Verzeichnis den Namen einer Migration trägt.
Meldung:
Dieses Modul scheitert mit H8103:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;Daneben migrations/2-more.sql/README:
This directory is not a migration.H8104
Neben dem Modul gibt es kein Verzeichnis migrations. Das Schema, gegen das eine Abfrage geprüft wird, entsteht aus den Migrationen in diesem Verzeichnis.
Meldung:
Dieses Modul scheitert mit H8104:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migration/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;H8105
Das Verzeichnis migrations enthält keine Datei, die auf .sql endet.
Meldung:
Dieses Modul scheitert mit H8105:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.txt:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;H8106
Eine Datei in migrations heißt nicht <Nummer>-<Name>.sql mit einer Nummer ab 1.
Meldung:
Dieses Modul scheitert mit H8106:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;H8107
Die Migrationen sind nicht lückenlos mit 1, 2, 3 und so weiter nummeriert, oder eine Nummer kommt zweimal vor.
Meldung:
Dieses Modul scheitert mit H8107:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;Daneben migrations/3-email.sql:
ALTER TABLE users ADD COLUMN email TEXT;H8108
Auf eine Anweisung in einer Migration folgt kein ;, bevor die nächste beginnt.
Meldung:
Dieses Modul scheitert mit H8108:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT
CREATE INDEX users_name ON users (name);H8109
Eine Migration enthält einen Parameter ?. Eine Migration läuft so, wie sie dasteht; ein Parameter darin hat nichts, wofür er stehen könnte.
Meldung:
Dieses Modul scheitert mit H8109:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL
) STRICT;
INSERT INTO users (name) VALUES (?);H8110
Ein Modul, das @query, @execute oder @migrations verwendet, importiert weder Standard.Sqlite noch Standard.SqlCipher. Der erzeugte Code ruft eines von beiden auf, und der Import wählt, welches.
Meldung:
Dieses Modul scheitert mit H8110:
module body Example is
function main(): ExitCode is
printLn(@migrations);
return ExitSuccess();
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8111
Das SQL eines @query oder @execute enthält mehr als eine Anweisung.
Meldung:
Dieses Modul scheitert mit H8111:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "DELETE FROM notes; DELETE FROM users");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8112
Das SQL hat eine andere Anzahl Parameter ?, als Werte übergeben werden.
Meldung:
Dieses Modul scheitert mit H8112:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users WHERE age > ?") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8113
Der Zeilentyp von @query ist kein Record, geschrieben Name oder Name[R], wobei R die Region ist, unter der der Text der Zeile verliehen wird.
Meldung:
Dieses Modul scheitert mit H8113:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "SELECT name FROM users") for row: Span[Nat8, Q] do
printLn(row);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8115
@query bekommt eine Anweisung, die keine Zeilen liefert. Man schreibt sie mit @execute oder ergänzt RETURNING.
Meldung:
Dieses Modul scheitert mit H8115:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
record Person[R: Region]: Free is
name: Span[Nat8, R];
end;
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
@query(&~db, "DELETE FROM users WHERE age > 99") for row: Person[Q] do
printLn(row.name);
else error do
printLn(describe(error));
end for;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;H8116
@execute bekommt eine Anweisung, die Zeilen liefert. Man schreibt sie mit @query ... for.
Meldung:
Dieses Modul scheitert mit H8116:
import Standard.Sqlite (Connection, Writing, SqlError, describe, openWriter, closeDatabase, migrate);
module body Example is
generic [R: Region]
function run(db: &![Connection[Writing], R]): Unit is
let result: Either[SqlError, Nat64] := @execute(&~db, "SELECT name FROM users");
case result of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as changed: Nat64) do
printLn(changed);
end case;
return nil;
end;
function main(): ExitCode is
case openWriter(":memory:") of
when Left(left as error: SqlError) do
printLn(describe(error));
return ExitFailure();
when Right(right as opened: Connection[Writing]) do
var db: Connection[Writing] := opened;
case migrate(&!db, @migrations) of
when Left(left as error: SqlError) do
printLn(describe(error));
when Right(right as applied: Index) do
run(&!db);
end case;
closeDatabase(db);
return ExitSuccess();
end case;
end;
end module body.Daneben migrations/1-schema.sql:
CREATE TABLE users (
id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
age INTEGER NOT NULL DEFAULT 0,
email TEXT,
score REAL
) STRICT;
CREATE TABLE notes (
id INTEGER PRIMARY KEY,
user_id INTEGER NOT NULL REFERENCES users (id),
body BLOB NOT NULL
) STRICT;9. Verträge
H2051
Der Body einer öffentlichen Funktion trägt requires-, ensures- oder raises-Klauseln. Der Vertrag einer öffentlichen Funktion steht einmal, in ihrem Interface, wo jeder Aufrufer ihn liest. Die Meldung nennt die Stelle des Vertrags im Interface, oder die der Deklaration, wenn das Interface keinen hat.
Meldung:
Dieses Modul scheitert mit H2051:
module body Example is
function half(n: Nat32): Nat32
requires n > 0
is
return n / 2;
end;
function main(): ExitCode is
printLn(half(8));
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
function half(n: Nat32): Nat32
requires n > 0;
function main(): ExitCode;
end module.H2052
Eine aus C importierte Funktion hat einen Vertrag. Der Compiler prüft einen Vertrag mit Anweisungen, die er in den Body der Funktion setzt, und eine mit Foreign_Import eingebundene Funktion hat keinen eigenen Body.
Meldung:
Dieses Modul scheitert mit H2052:
pragma Unsafe_Module;
module body Example is
pragma Foreign_Import(External_Name => "abs");
function cAbs(value: Int32): Int32
requires value > -100
is
end;
function main(): ExitCode is
printLn(cAbs(-5));
return ExitSuccess();
end;
end module body.H2053
Ein ensures nennt eine Variable, die der Body der Funktion deklariert. Ein ensures wird bei jedem return geprüft, wo die Variablen des Bodys noch gelten; ein Name, den der Body deklariert, würde dort gelesen statt des gleich geschriebenen Namens des Moduls. Das ensures liest nur die Parameter, result und alte Werte.
Meldung:
Dieses Modul scheitert mit H2053:
module body Example is
function addThree(n: Nat32): Nat32
ensures result > limit
is
let limit: Nat32 := 3;
return n + limit;
end;
function main(): ExitCode is
printLn(addThree(4));
return ExitSuccess();
end;
end module body.H2054
Eine Funktion mit einem ensures hat einen Parameter namens result. In einem ensures steht der Name result für den Wert, den die Funktion zurückgibt; ein Parameter dieses Namens wäre dort nicht zu lesen.
Meldung:
Dieses Modul scheitert mit H2054:
module body Example is
function doubled(result: Nat32): Nat32
ensures result > 0
is
return result * 2;
end;
function main(): ExitCode is
printLn(doubled(4));
return ExitSuccess();
end;
end module body.H2055
old steht, wo es nichts bedeutet: in einem requires, in einem anderen old oder mit anderem als einem Wert. old(e) ist der Wert, den e beim Eintritt in die Funktion hatte, bei ihrer Rückkehr wieder gelesen; in einem requires, das beim Eintritt geprüft wird, sagte es nichts. Die erste Zeile der Meldung sagt, welcher der drei Fälle vorliegt.
Meldung:
Dieses Modul scheitert mit H2055:
module body Example is
function half(n: Nat32): Nat32
requires old(n) > 0
is
return n / 2;
end;
function main(): ExitCode is
printLn(half(8));
return ExitSuccess();
end;
end module body.H2056
Eine Testfunktion hat ein requires. Ein verletztes requires nennt den Aufruf, der es gebrochen hat, und kein Aufruf im Programm ruft einen Test: das tut hilde test. Ein Test prüft, was er braucht, in seinem Body, mit den Zusicherungen von Standard.Testing.
Meldung:
Dieses Modul scheitert mit H2056:
module body Example.Test is
function testHalf(): Unit
requires argumentCount() > 0
is
return nil;
end;
end module body.Mit diesem Aufruf:
H2057
Ein Record mit einer Invariante lässt sich außerhalb seines Moduls bauen oder beschreiben. Eine Invariante wird bei der Rückkehr der öffentlichen Funktionen des Moduls geprüft, wo ein Wert das Modul verlässt. Das hält sie nur, wenn kein anderes Modul den Record bauen oder seine Slots zuweisen kann, und so ist es, wenn das Interface den Typ opak oder gar nicht deklariert. Ein Modul ohne Interface hat keinen privaten Record.
Meldung:
Dieses Modul scheitert mit H2057:
module body Example is
function main(): ExitCode is
let r: Range := Range(low => 1, high => 2);
printLn(r.high);
return ExitSuccess();
end;
end module body.Daneben Example.hih:
module Example is
record Range: Free is
low: Nat32;
high: Nat32;
invariant low <= high;
end;
function main(): ExitCode;
end module.H3096
Eine Bedingung verwendet einen linearen Wert selbst statt über eine Referenz. Eine Bedingung liest nur. Ein linearer Wert, selbst verwendet, wird verbraucht, und die Funktion hätte ihn verloren, bevor ihr Body läuft.
Meldung:
Dieses Modul scheitert mit H3096:
module body Example is
record Token: Linear is
value: Nat32;
end;
function valueOf(token: Token): Nat32 is
let { value: Nat32 } := token;
return value;
end;
function spend(token: Token): Nat32
requires valueOf(token) > 0
is
return valueOf(token);
end;
function main(): ExitCode is
printLn(spend(Token(value => 3)));
return ExitSuccess();
end;
end module body.H3097
Eine Bedingung nimmt eine Referenz zum Schreiben. Eine Bedingung liest nur; eine Referenz zum Schreiben hat darin keinen Platz. Eine Schreibreferenz, die ein Parameter ist, wird mit & gelesen.
Meldung:
Dieses Modul scheitert mit H3097:
module body Example is
record Counter: Linear is
count: Nat32;
end;
generic [R: Region]
function peek(counter: &[Counter, R]): Nat32 is
return counter->count;
end;
generic [R: Region]
function bump(counter: &![Counter, R]): Nat32 is
counter->count := counter->count + 1;
return counter->count;
end;
generic [R: Region]
function current(counter: &![Counter, R]): Nat32
requires bump(&~counter) > 0
is
return counter->count;
end;
function main(): ExitCode is
var c: Counter := Counter(count => 1);
printLn(current(&!c));
let { count: Nat32 } := c;
printLn(count);
return ExitSuccess();
end;
end module body.H3098
Eine Bedingung ruft eine Funktion, die ein Binding-Modul, C oder eine Referenz zum Schreiben erreicht. Der Compiler verfolgt jeden Aufruf einer Bedingung durch die Bodys der Funktionen, die er erreicht, bis in jede Tiefe. Die Meldung gibt die Kette der Aufrufe und was ihre letzte Funktion tut: Sie steht in einem Modul, dessen Name mit Bindings. beginnt, sie ist aus C importiert oder schreibt C mit @embed, oder sie nimmt eine Referenz zum Schreiben. In das eigene Modul des Compilers, Hilde.Pervasive, wird nicht hineingesehen; seine Parameter werden geprüft.
Meldung:
Dieses Modul scheitert mit H3098:
module body Example is
record Counter: Linear is
count: Nat32;
end;
generic [R: Region]
function peek(counter: &[Counter, R]): Nat32 is
return counter->count;
end;
generic [R: Region]
function bump(counter: &![Counter, R]): Nat32 is
counter->count := counter->count + 1;
return counter->count;
end;
function countedTwice(n: Nat32): Nat32 is
var c: Counter := Counter(count => n);
let first: Nat32 := bump(&!c);
let { count: Nat32 } := c;
return first + count;
end;
function half(n: Nat32): Nat32
requires countedTwice(n) > 0
is
return n / 2;
end;
function main(): ExitCode is
printLn(half(8));
return ExitSuccess();
end;
end module body.H3099
Eine Bedingung ruft über einen Funktionszeiger oder eine Methode eines Typparameters. Welche Funktion läuft, entscheidet sich später, am Wert des Zeigers oder am Typ, für den der Parameter steht, und der Compiler kann dort, wo die Bedingung geprüft wird, nicht in sie hineinsehen.
Meldung:
Dieses Modul scheitert mit H3099:
module body Example is
function double(n: Nat32): Nat32 is
return n * 2;
end;
function apply(f: Fn[Nat32, Nat32], n: Nat32): Nat32
requires f(n) > 0
is
return f(n);
end;
function main(): ExitCode is
printLn(apply(double, 4));
return ExitSuccess();
end;
end module body.H3100
old bekommt einen Wert, der nicht frei ist. old hebt eine Kopie seines Werts vom Eintritt bis zur Rückkehr auf, und ein linearer Wert lässt sich nicht kopieren.
Meldung:
Dieses Modul scheitert mit H3100:
module body Example is
record Token: Linear is
value: Nat32;
end;
function valueOf(token: Token): Nat32 is
let { value: Nat32 } := token;
return value;
end;
function fresh(): Token is
return Token(value => 1);
end;
function plusOne(n: Nat32): Nat32
ensures result = (n + valueOf(old(fresh())))
is
return n + 1;
end;
function main(): ExitCode is
printLn(plusOne(4));
return ExitSuccess();
end;
end module body.H3101
Eine Funktion mit einem requires wird als Funktionszeiger genommen. Der Compiler gibt jedem Aufruf einer Funktion mit einem requires die Stelle des Aufrufs mit, für die Meldung einer verletzten Bedingung; ein Aufruf über einen Zeiger hat keine solche Stelle.
Meldung:
Dieses Modul scheitert mit H3101:
module body Example is
function half(n: Nat32): Nat32
requires n > 0
is
return n / 2;
end;
function main(): ExitCode is
let f: Fn[Nat32, Nat32] := half;
printLn(f(8));
return ExitSuccess();
end;
end module body.H5008
Die Einstiegsfunktion hat ein requires. Ein verletztes requires nennt den Aufruf, der es gebrochen hat, und kein Aufruf im Programm ruft die Einstiegsfunktion.
Meldung:
Dieses Modul scheitert mit H5008:
module body Example is
function main(): ExitCode
requires argumentCount() > 0
is
return ExitSuccess();
end;
end module body.10. Fehlerarten
H2058
Die Methode einer Instanz trägt eine raises-Klausel. Die raises-Klausel einer Methode steht einmal, an der Deklaration der Methode in der Typklasse, wo jede Instanz und jeder Aufrufer sie liest; eine Instanz erbt sie. Eine Klausel an der Methode der Instanz wäre ein zweites Versprechen, das nichts gegen das erste hält, deshalb wird sie abgewiesen. Die Meldung nennt die Methode.
Meldung:
Dieses Modul scheitert mit H2058:
module body Example is
typeclass Measure(T: Free) is
method measure(value: T): Int32
raises Broken;
end;
instance Measure(Int32) is
method measure(value: Int32): Int32
raises Broken is
return value * 2;
end;
end;
function main(): ExitCode
raises Broken is
printLn(measure(21));
return ExitSuccess();
end;
end module body.H3102
Ein raise nennt eine Art, die die raises-Klausel der Funktion nicht nennt. Eine Funktion darf nur die Arten auslösen, die ihre eigene Klausel nennt. Die Meldung nennt die ausgelöste Art und die Arten der Klausel, oder sagt, dass die Funktion keine Klausel hat.
Meldung:
Dieses Modul scheitert mit H3102:
module body Example is
function pick(n: Int32): Int32
raises NotFound is
if n < 0 then
raise Denied;
end if;
return n;
end;
function main(): ExitCode
raises NotFound is
printLn(pick(7));
return ExitSuccess();
end;
end module body.H3103
Ein Aufruf kann mit einer Fehlerart enden, die die raises-Klausel des Aufrufers nicht nennt. Eine Funktion darf nur Funktionen aufrufen, deren Fehlerarten sie selbst nennt, damit eine Art keinen Aufrufer erreicht, der sie nicht versprochen hat; die Einstiegsfunktion unterliegt derselben Regel. Die Meldung nennt das Ziel, die fehlenden Arten und die Arten, die der Aufrufer nennt. Ein Methodenaufruf wird an der Klausel der Deklaration der Methode in der Typklasse gemessen.
Meldung:
Dieses Modul scheitert mit H3103:
module body Example is
function pick(n: Int32): Int32
raises NotFound is
return n;
end;
function main(): ExitCode is
printLn(pick(7));
return ExitSuccess();
end;
end module body.H3104
Eine Funktion mit einer raises-Klausel wird als Funktionszeiger genommen. Ein Aufruf über einen Zeiger hat keine Signatur, die der Compiler gegen die Klausel des Aufrufers halten könnte; eine solche Funktion wird nur bei ihrem Namen aufgerufen.
Meldung:
Dieses Modul scheitert mit H3104:
module body Example is
function pick(n: Int32): Int32
raises NotFound is
return n;
end;
function main(): ExitCode
raises NotFound is
let f: Fn[Int32, Int32] := pick;
printLn(f(7));
return ExitSuccess();
end;
end module body.11. Never und Slots
H2060
Ein return steht in einer Funktion, die Never zurückgibt. Eine solche Funktion hat keinen Wert zurückzugeben, also erreicht kein Pfad durch sie ein return.
Meldung:
Dieses Modul scheitert mit H2060:
module body Example is
function stop(): Never is
return nil;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2061
Eine Funktion, die Never zurückgibt, hat einen Pfad, der das Ende ihres Rumpfs erreicht. Hier hat das if kein else, also läuft der Pfad mit b gleich false durch.
Meldung:
Dieses Modul scheitert mit H2061:
module body Example is
function stop(b: Bool): Never is
if b then
abort("stopped");
end if;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2062
Eine Funktion, die Never zurückgibt, trägt eine ensures-Klausel. Die Klausel würde an einem return geprüft, und es gibt keines.
Meldung:
Dieses Modul scheitert mit H2062:
module body Example is
function stop(n: Int32): Never
ensures n > 0
is
abort("stopped");
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2063
Ein Slot hat weder einen Standardrumpf noch eine Implementierung im Programm. Die Prüfung läuft, wenn das letzte Modul des Programms übersetzt wird.
Meldung:
Dieses Modul scheitert mit H2063:
import Greeting (
greet
);
module body Example is
function main(): ExitCode is
greet();
return ExitSuccess();
end;
end module body.Daneben Greeting.hih:
module Greeting is
-- Says hello; the programme implements it.
pragma Slot;
function greet(): Unit;
end module.Daneben Greeting.hiq:
module body Greeting is
end module body.H2064
Zwei Funktionen des Programms implementieren denselben Slot. Ein Slot hat eine Implementierung, sonst wüsste der Compiler nicht, welche er aufruft.
Meldung:
Dieses Modul scheitert mit H2064:
module body Example is
pragma Implements(Name => "Hilde.Pervasive.onOverflow");
function first(message: Span[Nat8, Static]): Never is
abort(message);
end;
pragma Implements(Name => "Hilde.Pervasive.onOverflow");
function second(message: Span[Nat8, Static]): Never is
abort(message);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2065
Eine Implementierung eines Slots hat eine andere Signatur als der Slot. Die Parameter stimmen in Zahl, Name und Typ überein, und die Ergebnistypen sind gleich.
Meldung:
Dieses Modul scheitert mit H2065:
module body Example is
pragma Implements(Name => "Hilde.Pervasive.onOverflow");
function handled(text: Span[Nat8, Static]): Never is
abort(text);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2066
Ein pragma Implements nennt etwas, das kein Slot ist. Der Name wird unter den Slots der Module gesucht, die vor diesem übersetzt wurden.
Meldung:
Dieses Modul scheitert mit H2066:
module body Example is
pragma Implements(Name => "Hilde.Pervasive.nowhere");
function handled(message: Span[Nat8, Static]): Never is
abort(message);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H2067
Ein pragma Slot oder pragma Implements steht, wo es nichts bedeutet: Slot an einer Funktionsdefinition, Implements an einer Deklaration eines Interface, eines von beiden an einer Funktion, die über einen Typ generisch ist, oder beide an derselben Funktion. Ein Slot, der nur über Regionen generisch ist, ist erlaubt: Eine Region hat zur Laufzeit keine Form, und jede Instanz ist dieselbe Funktion. Die erste Zeile der Meldung sagt, welcher Fall es ist.
Meldung:
Dieses Modul scheitert mit H2067:
module body Example is
pragma Implements(Name => "Hilde.Pervasive.onOverflow");
generic [T: Free]
function handled(message: Span[Nat8, Static], other: T): Never is
abort(message);
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3109
Never steht als Typ von etwas, das einen Wert hält: ein Parameter, eine Variable, ein Feld eines Records oder einer Union, eine Konstante, eine Konversion, eine Größe, ein Funktionszeiger oder ein Typargument. Never hat keinen Wert, also kann nur das Ergebnis einer Funktion oder Methode ihn haben.
Meldung:
Dieses Modul scheitert mit H3109:
module body Example is
function take(x: Never): Unit is
return nil;
end;
function main(): ExitCode is
return ExitSuccess();
end;
end module body.H3110
Ein Aufruf einer Funktion, die Never zurückgibt, ist ein Argument oder ein Operand. Der Aufruf liefert nie einen Wert, also könnte der Ausdruck um ihn nie fertig werden. Ein let, eine Zuweisung, ein return und ein Zweig eines if-Ausdrucks dürfen einen solchen Aufruf weiter halten.
Meldung:
Dieses Modul scheitert mit H3110:
module body Example is
function show(n: Int32): Unit is
printLn(n);
return nil;
end;
function main(): ExitCode is
show(abort("stopped"));
return ExitSuccess();
end;
end module body.12. Ziele
H1038
Kein Compiler für wasm32-wasi wird gefunden. hilde findet ihn selbst: zig, gegeben als HILDE_ZIG oder im Pfad, das die C-Bibliothek von WASI mitbringt, sonst clang im Pfad mit wasm-ld und der C-Bibliothek von WASI. HILDE_WASM_CC=zig oder clang nimmt diesen und scheitert, wenn er fehlt; dann nennt ihn die Meldung. Das Beispiel nimmt den Pfad weg.
Meldung:
Dieses Modul scheitert mit H1038:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1039
HILDE_WASM_CC nennt einen Compiler, den hilde für WebAssembly nicht kennt. Es wählt zwischen den beiden, nach denen hilde sucht, zig und clang; ein falsch geschriebener Name wird abgewiesen, statt als nicht gesetzt zu gelten.
Meldung:
Dieses Modul scheitert mit H1039:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1040
hilde test --target=wasm findet keine Laufzeit für WebAssembly. Die Testprogramme sind Kommandomodule, und wasmtime führt sie aus.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1041
--target nennt kein Ziel, für das hilde baut. Die Namen sind die fünf von pragma Targets; für einen Namen, der wenige Buchstaben von einem entfernt ist, schlägt die Meldung diesen vor.
Meldung:
Dieses Modul scheitert mit H1041:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1042
--target nennt ein anderes System als das, auf dem hilde läuft. Ein Binary baut der C-Compiler der Maschine und linkt es gegen ihre C-Bibliothek, also wird es auf einer Maschine des Systems gebaut, für das es ist; nur WebAssembly, ein Modul, das auf jedem System läuft, wird überall gebaut.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1043
--target=wasm steht bei einem Archiv oder einem Shared Object. WebAssembly hat zwei Formen eines Moduls: ein Kommando, ein Programm mit main, und einen Reaktor, eine Bibliothek, die ihr Host aufruft.
Meldung:
Dieses Modul scheitert mit H1043:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H1044
Die Ausgabe eines Programms für wasm endet nicht auf .wasm. Ein Modul ist kein Binary des Systems: Sein Name sagt, was es ist, und wasmtime und ein Host in JavaScript nehmen es unter diesem Namen.
Meldung:
Dieses Modul scheitert mit H1044:
module body Example is
function main(): ExitCode is
return ExitSuccess();
end;
end module body.Mit diesem Aufruf:
H2068
Ein pragma Targets nennt kein Ziel, eines doppelt, eines, das es nicht gibt, oder ein Instead, das kein Modul ist. Instead nennt ein Modul mit seinem vollen Namen, und nur, wo ein Ziel fehlt.
Meldung:
Dieses Modul scheitert mit H2068:
import Standard.Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
pragma Targets(Names => "linux plan9");
module Standard.Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Standard.Thing is
function size(): Index is
return 1;
end;
end module body.H2069
Ein anderes Pragma als ein pragma Targets steht vor einem Modul-Interface. Was ein Modul bindet und ob es unsicher ist, steht vor seinem Body.
Meldung:
Dieses Modul scheitert mit H2069:
import Standard.Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
pragma Unsafe_Module;
pragma Targets(Names => "linux openbsd freebsd darwin wasm");
module Standard.Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Standard.Thing is
function size(): Index is
return 1;
end;
end module body.H2070
Ein Modul außerhalb der Standardbibliothek nennt seine Ziele. Ein Programm wählt die Ziele nicht, für die es gebaut wird: Es gibt es für die der Module, die es importiert, und der Compiler hält es daran. Die Standardbibliothek ist ein Modul, dessen Name mit Standard. oder Bindings. beginnt.
Meldung:
Dieses Modul scheitert mit H2070:
import Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
pragma Targets(Names => "linux openbsd freebsd darwin wasm");
module Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Thing is
function size(): Index is
return 1;
end;
end module body.H2071
Ein Interface der Standardbibliothek nennt keine Ziele. Jedes Modul, dessen Name mit Standard. beginnt, sagt, für welche Ziele es es gibt, damit ein Programm, das für eines gebaut wird, es an seinen Importen merkt und nicht beim Linken.
Meldung:
Dieses Modul scheitert mit H2071:
import Standard.Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
module Standard.Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Standard.Thing is
function size(): Index is
return 1;
end;
end module body.H2072
Ein Modul nennt ein Ziel, für das es einen seiner Importe nicht gibt. Das gilt, wofür das Programm auch gebaut wird, also können die Ziele der Standardbibliothek nicht mehr behaupten, als sie haben.
Meldung:
Dieses Modul scheitert mit H2072:
import Standard.Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
pragma Targets(Names => "linux openbsd freebsd darwin wasm");
import Standard.Other (
one
);
module Standard.Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Standard.Thing is
function size(): Index is
return 1;
end;
end module body.Daneben Other.hih:
pragma Targets(Names => "linux openbsd freebsd darwin");
module Standard.Other is
function one(): Index;
end module.Daneben Other.hiq:
module body Standard.Other is
function one(): Index is
return 1;
end;
end module body.H2073
Ein Programm, das für ein Ziel gebaut wird, importiert ein Modul, das es dafür nicht gibt. Die Meldung nennt die Ziele, für die es das Modul gibt, und, wo sein pragma Targets eines nennt, das Modul, das stattdessen zu nehmen ist; --error-format=json und hilde-json tragen dieses Modul als Vorschlag.
Meldung:
Dieses Modul scheitert mit H2073:
import Standard.Thing (
size
);
module body Example is
function main(): ExitCode is
let n: Index := size();
return ExitSuccess();
end;
end module body.Daneben Thing.hih:
pragma Targets(Names => "linux openbsd freebsd darwin", Instead => "Standard.Other");
module Standard.Thing is
function size(): Index;
end module.Daneben Thing.hiq:
module body Standard.Thing is
function size(): Index is
return 1;
end;
end module body.Mit diesem Aufruf:
13. Pakete
H1045
Ein Paketkommando wurde gegeben, und hilde-pkg liegt nicht neben dem Compiler.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1046
hilde-pkg liegt neben dem Compiler und ließ sich nicht starten.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1501
Das Kommando braucht ein Paket, und im Verzeichnis liegt keine hilde.toml.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1502
hilde.toml ist kein TOML; die Meldung nennt Zeile und Spalte.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1503
hilde.toml hat einen Schlüssel oder eine Tabelle, die ein Manifest nicht hat, etwa einen vertippten.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1504
Ein Schlüssel, den hilde.toml haben muss, fehlt: Name oder Version des Pakets, git-URL oder Version einer Anforderung.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1505
Ein Wert hat die falsche Form: ein Name, der kein Modulpräfix ist, eine Version, die nicht vX.Y.Z ist, eine Fähigkeit, die es nicht gibt, oder ein Argument falscher Form.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1506
Ein Präfix kommt von zwei git-URLs, oder ein Paket heißt anders als das Präfix, unter dem es verlangt wird.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1507
git ist nicht im PATH, und das Kommando braucht es.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1508
git ist gescheitert: eine falsche URL, ein Repository, das nicht gelesen werden darf, oder ein Programm, das sich nicht starten ließ.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1509
Das Repository hat keinen Tag der verlangten Version; der Vorschlag nennt die nächstliegenden Tags.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1510
Der Baum eines Pakets enthält einen symbolischen Link oder eine Sonderdatei.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1511
Ein Release hat keine Signatur, und die Richtlinie des Pakets verlangt eine.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1512
Eine Signatur hält nicht, der Schlüssel ist nicht der bei der ersten Verwendung übernommene, oder ein Release ist nach einem signierten unsigniert.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1513
Der geheime Schlüssel lässt sich nicht lesen, ist kein signify-Schlüssel oder hat eine Passphrase.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1514
hilde.sum fehlt, hat eine falsche Zeile oder keine Zeile für eine Anforderung.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1515
Ein Baum in vendor/ fehlt, ist geändert oder steht nicht in hilde.sum.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1516
Zwei Hauptversionen eines Pakets werden verlangt; eine neue Hauptversion bekommt ein neues Präfix.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1517
Der Baum eines Pakets ist tiefer als 64 Verzeichnisse.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1518
Ein Verzeichnis oder eine Datei eines Pakets lässt sich nicht lesen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1519
Eine Datei oder ein Verzeichnis lässt sich nicht schreiben.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1521
hilde new oder ein Schlüssel würde über etwas schreiben, das schon da ist.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1522
hilde doc findet kein Modul und keine Deklaration des Namens.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1523
Ein Ziel aus hilde.toml erlaubt das pragma Targets eines erreichten Moduls nicht.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1530
Die Version eines Releases ist niedriger, als die Änderung der Schnittstelle verlangt, etwa ein Bruch unter einer Nebenversion.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1531
Ein Modul des Pakets hat keine Testdatei.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1532
Die Tests des Pakets laufen nicht durch, oder der Compiler scheiterte daran.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1533
Eine exportierte Funktion wird in keinem Test aufgerufen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1534
Die Version eines Releases ist nicht neuer als der neueste Tag.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1535
Keine cargo gefunden: keines auf PATH und keines in HILDE_CARGO genannt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1536
Die Umgebung oder eine Konfiguration von cargo verlangt panic = "abort", unter dem keine Bridge einen panic fangen kann.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1537
Eine Datei in rust/bridge ist kein Bridge-Modul, es gibt keines, oder eine Funktion einer Bridge beginnt nicht mit dem Guard.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1538
cargo schlug fehl, schrieb keine statische Bibliothek, schrieb eine zweite oder nannte keine nativen Bibliotheken.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1539
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1540
Die rust-toolchain.toml oder das Guard-Crate rust/hilde-bridge neben dem Compiler fehlt oder nennt keine feste Version.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1541
Der Wert von --target ist nicht wie ein Ziel von rustc geschrieben.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
14. Sperli
H1047
Ein run-Kommando wurde gegeben, und hilde-launcher liegt nicht neben dem Compiler.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1048
hilde-launcher liegt neben dem Compiler und ließ sich nicht starten.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1601
Der Partner zeigte kein Zertifikat, eines, für das die CA des Jobs nicht bürgt, oder bot eine TLS-Version unter 1.3 an.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1602
Der Subject des Zertifikats des Partners ist nicht der Job und der Rang, für den die Verbindung gilt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1603
Ein Host steht in SPERLI_REFUSED_HOSTS, ist host-a.invalid oder host-b.invalid oder ein Name darunter oder steht auf der Sperrliste des Betreibers; eine Sperrliste hebt die Regel nicht auf.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1604
Das Join-Token eines Partners ist abgelaufen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1605
Das Join-Token eines Partners wurde für einen anderen Job ausgestellt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1606
Das Join-Token eines Partners wurde für einen anderen Rang, eine andere Größe, Inkarnation oder einen anderen Host ausgestellt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1607
Das Join-Token eines Partners ist missgebildet, oder seine Signatur gilt unter dem öffentlichen Schlüssel des Starters nicht.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1608
Ein Frame kündigt mehr Nutzlast an als die Grenze von 16 MiB; er wird abgewiesen, bevor ein Byte der Nutzlast gelesen wird.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1609
Ein Frame gehört zu einer älteren Inkarnation des Jobs; seine Nutzlast wird gelesen und verworfen, und das Warten geht weiter.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1610
Der Kopf eines Frames bricht eine Regel des Protokolls: ein unbekannter Typ, ein Flag, ein Dienst oder eine Mitgliedschaftsepoche ungleich 0, ein anderer Job, andere Ränge oder eine neuere Inkarnation.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1611
Ein Partner ging verloren: Die Verbindung wurde geschlossen, oder innerhalb der Stillegrenze kam kein Frame.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1612
Ein Partner schickte einen Abort-Frame.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1613
Das Hello eines Partners fehlt, kommt zweimal, hat eine andere Version oder bietet keinen Punkt-zu-Punkt-Dienst an.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1614
Die Kommandozeile von hilde run oder seine Hostliste ist falsch: eine fehlende oder unbekannte Option, eine Zahl außerhalb des Bereichs, kein Host oder eine Zeile, die kein Host mit Port ist.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1615
Ein Rang ließ sich nicht starten, oder die Schlüssel, Zertifikate oder Ports des Jobs ließen sich nicht herstellen.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1616
Die Jobbeschreibung, die ein Rang auf der Standardeingabe bekam, ist missgebildet.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1617
Ein Kollektiv-Frame passt nicht zu dem Aufruf, den er beantwortet: andere Operation, anderer Typ, andere Reduktion, Phase, Wurzel oder Folgenummer, oder Beiträge eines gather verschiedener Länge.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1618
Die Argumente eines Kollektiv-Aufrufs sind falsch: eine Wurzel außerhalb des Jobs, ein Elementtyp und eine Reduktion, die nicht zusammenpassen, Daten, die keine ganze Zahl von Elementen oder Blöcken sind, oder Beiträge eines reduce verschiedener Länge.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1619
Eine Checkpoint-Datei hat eine andere Magic oder Version oder einen Job, eine Epoche, einen Rang, eine Größe oder eine Länge, die nicht die erwartete ist, oder sie ist zu kurz.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1620
Das SHA-256 des Zustands in einer Checkpoint-Datei ist nicht das in ihrem Kopf oder nicht das, das die COMMIT-Datei für den Rang aufführt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1621
Eine COMMIT-Datei ist missgebildet, gehört zu einem anderen Job oder einer anderen Epoche, oder ihre CompositeSig-Signatur gilt für den öffentlichen Schlüssel des Jobs nicht. Eine Epoche ohne gültige COMMIT-Datei zählt nicht.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1622
Ein resume fand keine Epoche mit gültiger COMMIT-Datei und allen Rang-Dateien, oder die Ränge einigten sich nicht auf die Epoche.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1623
Ein resume wurde für einen Job mit anderer Rangzahl verlangt, als der Checkpoint geschrieben wurde. Version 1 des Formats verlangt dieselbe Größe.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1624
Ein Checkpoint wurde verlangt, während auf diesem Rang noch ein send oder receive offen war.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.
H1625
Ein Checkpoint konnte nicht geschrieben oder gesendet werden, oder es wurde kein Checkpoint-Verzeichnis genannt.
Meldung:
Der Katalog gibt für diesen Code kein fehlschlagendes Beispiel.