Abstrakte Wikipedia/Darstellung von Fehlern

Motivation und Begründung

In Wikifunctions können Fehler aus vielen verschiedenen Gründen auftreten: Wenn eine Eingabe nicht interpretiert werden kann, wenn ein Wert nicht berechnet werden kann, wenn wir nicht genügend Ressourcen haben, um ein Ergebnis zu berechnen, und vieles mehr. Darüber hinaus können Fehler auch kontrolliert auftreten und bei benutzerdefinierten Funktionen erzeugt und ausgegeben werden.

Aus diesem Grund bietet Wikifunctions eine einheitliche Möglichkeit, um Fehler mit den Typen Z5/Fehler und Z50/Fehlertyp darzustellen und zu melden. In ähnlicher Weise gibt es im ZID-Bereich von Z500 bis Z599 eine Vielzahl von integrierten Instanzen von Fehlertypen, die die Fehler enthalten, die durch interne Systemausfälle oder -probleme generiert und zurückgegeben werden.

Instanzen von Z50/Fehlertyp können (und sollten wahrscheinlich) beibehalten werden, damit ihre Bezeichnungen, die die Beschreibung des Fehlers enthalten, übersetzt werden können. Andererseits werden Instanzen von Z5/Fehler während der Laufzeit generiert (ZObjekte vom Typ Z5 sind nie persistent), wenn ein Problem auftritt. Die an den Benutzer zurückgegebene Instanz von Z5/Fehler enthält: 1) eine Referenz auf den Fehlertyp, der das Problem genauer beschreibt, und 2) die spezifischen Daten, die diesen Fehler generiert haben.

Z5/Fehler

Jeder Fehler ist ein ZObjekt. Fehler haben alle den Typ Z5/Fehler, der zwei Schlüssel hat:

• Z5K1/Fehlertyp (Z50/F3): Akzeptiert ein Objekt vom Typ Z50, das den Fehlertyp beschreibt, der von diesem Z5 gemeldet wird. Normalerweise handelt es sich um eine Referenz auf einen der unten beschriebenen vordefinierten Fehlertypen.
• Z5K2/Fehlerwert (Z1/Jedes): Eine Instanz des im Schlüssel Z5K1 beschriebenen Fehlertyps. Sie enthält die zusätzlichen Informationen, um die falschen Werte zu identifizieren.

Hier ist ein einfaches Beispiel.

Angenommen, wir bitten unsere Validierungsmaschine, die Wohlgeformtheit des folgenden ZObjekts zu überprüfen:

{ "value": "test" }

{ "Z6K1": "test" }

Wir sollten einen Fehler zurückerhalten, da der Z1K1/Typ auf dem angegebenen ZObjekt fehlt. Der genaue Fehler kann von der Evaluierungsmaschine abhängen, es sollte jedoch eine Form eines Fehlers wegen Nicht-Wohlgeformtheit zurückgegeben werden. Hier ist eine mögliche Antwort.

{ "type": "Error", "error type": "not well-formed error", "error value": { "type": { "type": "Function call", "function": "Errortype to type", "errortype": "not well-formed error" }, "error type": "missing Z1K1", "error value": { "type": { "type": "Function call", "function": "Errortype to type", "errortype": "missing Z1K1" }, "object": { "type": "Quote", "quotation": { "value": "test" } } } } }

{ "Z1K1": "Z5", "Z5K1": "Z502", "Z5K2": { "Z1K1": { "Z1K1": "Z7", "Z7K1": "Z885", "Z885K1": "Z502" }, "Z502K1": "Z523", "Z502K2": { "Z1K1": { "Z1K1": "Z7", "Z7K1": "Z885", "Z885K1": "Z523" }, "Z523K1": { "Z1K1": "Z99", "Z99K1": { "Z6K1": "test" } } } } }

Dies zeigt ein ziemlich kompliziertes Muster, bei dem eine Fehlerhierarchie es dem System ermöglicht, nach bestimmten Fehlertypen zu filtern. In diesem Fall umfasst die Hierarchie sowohl Z502/Nicht wohlgeformt als auch Z523/Z1K1 fehlt. Wir können leicht erkennen, dass es sich um einen Fehler handelt, da er wie jeder Fehler mit Z5/Fehler als höchstem Typ beginnt. Wir werden uns Z523 im nächsten Abschnitt genauer ansehen.

Z50/Fehlertypen

Fehlertypen werden durch Z50 dargestellt und haben eine sehr ähnliche Form wie Objekte vom Typ Z4/Typ. Sie haben einen Schlüssel, Z50K1, der eine Liste der Z3/Schlüssel enthält, die zur Beschreibung des Fehlers erforderlich sind.

Zum Beispiel nach dem vorherigen Beispiel: Z523 ist ein ZObjekt des Typs Z50/Fehlertyp, und seine Definition lautet:

{ "type": "Error type", "keys": [ { "type": "Key", "value type": "Quote", "key id": "Z523K1", "label": { "type": "Multilingual text", "texts": [ { "type": "Monolingual text", "language": "English", "text": "object" } ] } } ] }

{ "Z1K1": "Z50", "Z50K1": [ { "Z1K1": "Z3", "Z3K1": "Z99", "Z3K2": "Z523K1", "Z3K3": { "Z1K1": "Z12", "Z12K1": [ { "Z1K1": "Z11", "Z11K1": "Z1002", "Z11K2": "object" } ] } } ] }

Wir sehen hier, dass Z523 einen einzigen Schlüssel mit der ID Z523K1 und der englischen Bezeichnung "object" vom Typ Z99/Zitat hat. Der Wert dieses Schlüssels ist das (zitierte) Objekt, bei dem festgestellt wurde, dass ein Z1K1 fehlt. (Z99/Zitat wird hier als Wrapper um das fehlerhafte Objekt verwendet, um anzuzeigen, dass es während der Verarbeitung von Z523 nicht evaluiert werden soll.) Diese Fehlertypdefinition wird als Z523 beibehalten und der Schlüssel Z2K1 (Bezeichnung des persistenten Objekts), der hier nicht dargestellt ist, enthält den multilingualen Namen des Fehlertyps: "Z1K1 fehlt". Sieh dir die vollständige JSON-Definition der Daten an.

Wenn ein Fehler vom Typ Z523/"Z1K1 fehlt" erkannt wird, erstellen wir ein Objekt vom Typ Z5/Fehler, indem wir:

1. Eine Referenz auf den Fehlertyp Z523 als Wert von Z5K1 hinzufügen, und
2. Eine Instanz vom Fehlertyp Z523 erstellen.

Instanzen von Fehlertypen

Um eine Instanz eines Fehlertyps zu erstellen, müssen wir diesen Fehlertyp zuerst in einen formalen Typ umwandeln. Dazu rufen wir die Funktion Z885/"Fehlertyp zu Typ" auf.

Diese Funktion verwendet die in Z50K1 aufgelisteten Schlüssel, um einen Z4/Typ mit diesen Schlüsseln als Z4K2 zu erstellen und zurückzugeben. Siehe die Funktionskomposition Z995, die Z885 implementiert.

Eine Instanz eines Fehlertyps hat dann als Typ das Ergebnis des Funktionsaufrufs an Z885, wobei in diesem Fall die Fehlertyp-ID Z523 als Argument Z885K1 übergeben wird.

{ "type": { "type": "Function call", "function": "Errortype to type", "errortype": "Missing Z1K1" } }

{ "Z1K1": { "Z1K1": "Z7", "Z7K1": "Z885", "Z885K1": "Z523" } }

Wenn du den aus diesem Aufruf resultierenden Z4/Typ sehen möchtest, versuche, die wikilambda_function_call-API mit der folgenden Eingabe auszuführen:

{
  "Z1K1": "Z7",
  "Z7K1": "Z885",
  "Z885K1": "Z523"
}

Versuche es in Notwikilambda

Die Antwort wird der folgende Z4/Typ sein:

{ "type": "Type", "identity": { "Z1K1": "Z7", "Z7K1": "Z885", "Z885K1": "Z523" }, "keys": [ { "type": "Key", "value type": "Quote", "key id": "Z523K1", "label": { "type": "Multilingual text", "texts": [ { "type": "Monolingual text", "language": "English", "text": "object" } ] } } ], "validator": "Z101" }

{ "Z1K1": "Z4", "Z4K1": { "Z1K1": "Z7", "Z7K1": "Z885", "Z885K1": "Z523" }, "Z4K2": [ { "Z1K1": "Z3", "Z3K1": "Z99", "Z3K2": "Z523K1", "Z3K3": { "Z1K1": "Z12", "Z12K1": [ { "Z1K1": "Z11", "Z11K1": "Z1002", "Z11K2": "object" } ] } } ], "Z4K3": "Z101" }

Verschachtelung von Fehlern

Vor der Persistenz oder Ausführung durchlaufen ZObjekte einen synchronen Prozess der statischen Validierung oder Wohlgeformtheit. Diese Validierung wird durchgeführt, indem das angegebene ZObjekt mit den Definitionen des JSON-Schemas verglichen wird, die in den Funktionsschemata gefunden werden, entweder in der WikiLambda-Erweiterung (unter Verwendung des opis-JSON-Schemas) oder in den NodeJS-Back-End-Diensten (unter Verwendung des Ajv-JSON-Schema-Validierers).

Da ein ZObjekt ein verschachteltes ZObjekt ist, kann ein übergeordneter Schlüsselwert aufgrund eines Fehlers in einem untergeordneten Schlüsselwert ungültig sein. Zum Beispiel im folgenden ZObjekt:

{
 "Z1K1": "Z12",
 "Z12K1": [
  {
   "Z1K1": "Z11",
   "Z11K1": "Z1002",
   "Z11K2": "true"
  },
  {
   "Z1K1": "Z11",
   "Z11K1": "Z1002",
   "Z11K2": false
  }
 ]
}

Der Wert für das erste Z11K2 (Zeile 7) ist korrekt, der Wert für das zweite Z11K2 (Zeile 12) jedoch nicht. Das bedeutet, dass das erste ZObjekt vom Typ Z11/monolinguale Zeichenkette aus der Liste korrekt ist, während das zweite falsch ist. Der Validierungsfehler vom zweiten Element dieser Liste würde sich dann bis zu seinen übergeordneten Objekten ausbreiten und auch statische Validierungsfehler auslösen in:

1. der ganzen Liste (Zeilen 3-14),
2. dem Wert von Z12K1, und schließlich,
3. dem ganzen ZObjekt Z12/multilinguale Zeichenkette.

Die statische Validierung für das obige Objekt erzeugt ein Z5/Fehlerobjekt, das genau diesen Baum von Validierungsfehlern darstellt und dem Zweig nach unten Schlüssel für Schlüssel folgt, bis das Problem mit dem genauen Wert erreicht ist. Eine vereinfachte Darstellung des obigen Fehlers ist:

{
 "Z1K1": "Z5",
 "Z5K1": "Z502",       // Root error. Z502: "Not wellformed" error
 "Z5K2": {
  "Z1K1": "Z502",
  "Z502K1": "Z526",    // What's the internal error? Z526 
  "Z502K2": {          // Okay, let's see it.
   "Z1K1": "Z5",
   "Z5K1": "Z526",      // Z526: "Key value not wellformed" error
   "Z5K2": {
    "Z1K1": "Z526",
    "Z526K1": "Z12K1",  // Which is the non-valid key? "Z12K1"
    "Z526K2": {         // Sure, but why?
     "Z1K1": "Z5",
     "Z5K1": "Z522",   // Z522: "Array element not wellformed" error
     "Z5K2": {
      "Z1K1": "Z522",
      "Z522K1": "1",   // Which element is not valid? The one with index "1"
      "Z522K2": {      // Okay. But, why?!
       "Z1K1": "Z5",
       "Z5K1": "Z526",      // Z526: "Key value not wellformed" error
       "Z5K2": {
        "Z1K1": "Z526",
        "Z526K1": "Z11K2",  // Which is the non valid key this time? "Z11K2"
        "Z526K2": {         // Can I know why?
         "Z1K1": "Z5",
         "Z5K1": "Z521",   // Z521: "ZObjects must not be a number or Boolean or null" error
         "Z5K2": {
          "Z1K1": "Z521",
          "Z521K1": {      // What's the offending value?
           "Z1K1": "Z99",
           "Z99K1": false  // Here, this one.
          }
         }
        }
       }
      }
     }
    }
   }
  }
 }
}

Bitte beachte, dass das obige ZObjekt aus Gründen der Lesbarkeit vereinfacht wurde, aber ein Typ wie "Z1K1": "Z526" ist nicht gültig und sollte stattdessen als Typ das Ergebnis des Funktionsaufrufs Z885 (Fehlertyp zu Typ) verwenden, wie oben erklärt.

Zur Beschreibung von Stamm- oder/und Verzweigungsfehlern stehen folgende Fehlertypen zur Verfügung:

• Z502: Fehler "Nicht wohlgeformt": Dies ist der Stammfehlertyp für jeden Fehlerbaum, der bei der statischen Validierung zurückgegeben wird. Sein zweiter Schlüssel enthält den Fehler oder die Fehler, die während des Parsing-Prozesses gefunden wurden.
• Z526: Fehler "Schlüsselwert nicht wohlgeformt": Dies ist ein Verzweigungsfehlertyp. Sein erster Parameter gibt Auskunft darüber, welcher Schlüssel ein ungültiges ZObjekt enthält, und sein zweiter Parameter ist der Fehler, der von unten weitergegeben wird.
• Z522: Fehler "Array-Element nicht wohlgeformt": Dies ist ebenfalls ein Verzweigungsfehlertyp. Er kann nur während der Validierung eines kanonischen Objekts zurückgegeben werden, da dies das einzige Formular ist, das JSON-Arrays zulässt. Sein erster Parameter stellt den Index des Fehlers bereit, der den Validierungsfehler verursacht hat (beginnend bei 0), während sein zweiter Parameter den weitergegebenen Fehler enthält.

Arbeit mit Z509/Liste von Fehlern

Wenn mehrere Fehler zurückgegeben werden müssen, werden diese in einen übergeordneten Fehler vom Typ Z509/Liste von Fehlern eingeschlossen. Ein Fehler vom Typ Z509 enthält eine Liste von ZObjekten des Typs Z5/Fehler und kann Verzweigungsfehlertypen sowie Blattfehlertypen enthalten. Beispielsweise würde ein ZObjekt vom Typ Z3/Schlüssel wie das folgende aus zwei Gründen einen Validierungsfehler auslösen:

1. Der Schlüssel Z3K2 enthält eine Zahl, die ein unzulässiger Werttyp ist.
2. Der verpflichtende Schlüssel Z3K3 fehlt.

{
	"Z1K1": "Z3",
    "Z3K1": "Z6",
	"Z3K2": 34
}

Die statische Validierung dieses ZObjekts würde dann einen Validierungsfehler verursachen, der zwei separate Fehlerzweige enthält:

{
 "Z1K1": "Z5",
 "Z5K1": "Z502",      // Root error of type Z502: "Not wellformed"
 "Z5K2": {
  "Z1K1": "Z502",
  "Z502K1": "Z509",   // What's the internal error? "Z509"
  "Z502K2": {         // Okay, let's see it.
   "Z1K1": "Z5",
   "Z5K1": "Z509",    // Z509: "List of errors" error
   "Z5K2": {
    "Z1K1": "Z509",
    "Z509K1": [       // What errors were found?
     {
      "Z1K1": "Z5",       // First error from the list:
      "Z5K1": "Z526",     // Non terminal error of type Z526: "Key value not wellformed"
      "Z5K2": {
       "Z1K1": "Z526",
       "Z526K1": "Z3K2",  // Which is the non valid key? "Z3K2"
       "Z526K2": {        // Why?
        "Z1K1": "Z5",
        "Z5K1": "Z521",   // Z521: "ZObjects must not be a number or Boolean or null" error
        "Z5K2": {
         "Z1K1": "Z521",
         "Z521K1": {      // What's the offending value?
          "Z1K1": "Z99",
          "Z99K1": 34     // Here, this value is wrong.
         }
        }
       }
      }
     },
     {
      "Z1K1": "Z5",       // Second error from the list:
      "Z5K1": "Z511",     // Terminal error of type Z511: "Key not found"
      "Z5K2": {
       "Z1K1": "Z511",
       "Z511K1": "Z3K3",  // Which is the missing key? "Z3K3"
       "Z511K2": {        // Where is it missing from?
        "Z1K1": "Z99",
        "Z99K1": {        // From here.
         "Z1K1": "Z3",
         "Z3K1": "Z6",
         "Z3K2": 34
        }
       }
      }
     }
    ]
   }
  }
 }
}

Wie gezeigt kann die Fehlerliste, die den Wert des Fehlers Z509/Liste von Fehlern bildet, Fehler auf Verzweigungsebene (wie den ersten vom Typ Z526/Schlüsselwert nicht wohlgeformt) sowie Blattfehler (wie der zweite in der Liste, vom Typ Z511/Schlüssel nicht gefunden) enthalten. Ebenso kann ein Fehler vom Typ Z509/Liste von Fehlern viele Male und auf jeder Ebene des Fehlerbaums gefunden werden.

Zum Beispiel für ein ungültiges ZObjekt wie dieses, wo dem einzigen Element in der Liste der Z11/monolinguale Zeichenketten zwei verpflichtende Schlüssel fehlen: Z11K1 und Z11K2:

{
 "Z1K1": "Z3",
 "Z3K1": "Z6",
 "Z3K2": "Z1000K1",
 "Z3K3": {
  "Z1K1": "Z12",
  "Z12K1": [
   {
    "Z1K1": "Z11"
   }
  ]
 }
}

Der Fehler vom Typ Z509/Liste von Fehlern tritt erst auf, wenn der direkte übergeordnete Teil beider Fehler auftaucht und beide Fehler in der Liste Blattfehler des Typs Z511/Schlüssel nicht gefunden sind:

{
 "Z1K1": "Z5",
 "Z5K1": "Z502",     // Root error of type Z502: "Not wellformed"
 "Z5K2": {
  "Z1K1": "Z502",
  "Z502K1": "Z526",  // What's the internal error? Z526 
  "Z502K2": {        // Okay, let's see it.
   "Z1K1": "Z5",
   "Z5K1": "Z526",         // Non terminal error of type Z526: "Key value not wellformed"
   "Z5K2": {
    "Z1K1": "Z526",
    "Z526K1": "Z3K3",      // Which is the non-valid key? "Z3K3"
    "Z526K2": {            // Okay, why?
     "Z1K1": "Z5",
     "Z5K1": "Z526",       // Non terminal error of type Z526: "Key value not wellformed"
     "Z5K2": {
      "Z1K1": "Z526",
      "Z526K1": "Z12K1",   // Which is the non-valid key? "Z12K1"
      "Z526K2": {          // Again, why?
       "Z1K1": "Z5",
       "Z5K1": "Z522",     // Non terminal error of type Z522: "Array element not wellformed"
       "Z5K2": {
        "Z1K1": "Z522",
        "Z522K1": "0",     // Which element is not valid? The one with index "0"
        "Z522K2": {        // What's wrong with it?
         "Z1K1": "Z5",
         "Z5K1": "Z509",   // Z509: "List of errors" error
         "Z5K2": {
          "Z1K1": "Z509",
          "Z509K1": [
           {
            "Z1K1": "Z5",        // First error from the list, a terminal one:
            "Z5K1": "Z511",      // Z511: "Key not found" error
            "Z5K2": {
             "Z1K1": "Z511",
             "Z511K1": "Z11K1",  // Which is the missing key? "Z11K1"
             "Z511K2": {         // Where is it missing from?
              "Z1K1": "Z99",
              "Z99K1": {         // From here.
               "Z1K1": "Z11"
              }
             }
            }
           },
           {
            "Z1K1": "Z5",        // Second error from the list, also a terminal one:
            "Z5K1": "Z511",      // Z511: "Key not found" error
            "Z5K2": {
             "Z1K1": "Z511",
             "Z511K1": "Z11K2",  // Which is the missing key? "Z11K2"
             "Z511K2": {         // Where is it missing from?
              "Z1K1": "Z99",
              "Z99K1": {         // From here.
               "Z1K1": "Z11"
              }
             }
            }
           }
          ]
         }
        }
       }
      }
     }
    }
   }
  }
 }
}

Vordefinierte Fehlertypen

Für vordefinierte Fehlertypen ist der ZID-Bereich Z500-Z599 reserviert. Hier ist eine Liste aller vordefinierten Fehlertypen, die derzeit von den verschiedenen Teilen des Wikifunctions-Stacks verwendet werden. Die Tabelle enthält auch Einzelheiten zu ihren Argumenten, ihren Namen und ihrem relevanten Anwendungsbereich. Nach jedem Argument geben wir in Klammern die Art der Werte an, die das Argument verwendet.

ZID	Scope	Arguments	Name
Z500	global	error information (Z1)	Generic error
Z501	global	error message (Z6), input (Z6)	JSON syntax error
Z502	global	subtype (Z50), value (Z5)	Not wellformed
Z503	executor	feature name (Z6)	Not implemented yet
Z504	global	ZID (Z6)	ZID not found
Z505	executor	expected (Z6), actual (Z6), args (Z10)	Number of arguments mismatch
Z506	executor	expected (Z4), actual (Z4), arg (Z1), propagated error (Z5)	Argument type mismatch
Z507	executor	function call (Z7), propagated error (Z5)	Error in evaluation
Z508	executor	key (Z39), object (Z99)	Competing keys
Z509	global	errors (Z10)	List of errors
Z510	-	-	NIL
Z511	global	key (Z39), object (Z99)	Key not found
Z512	global	expected result (Z99), actual result (Z99)	Test failed
Z513	executor	object (Z99)	Resolved persistent object without value
Z514	executor	implementation (Z14)	Built-in does not exist
Z515	executor	implementation (Z14)	Built-in ID is erroneous
Z516	executor	argument (Z18), bad value (Z99)	Argument value error
Z517	executor	expected type (Z4), actual type (Z4), returned value (Z1), propagated error (Z5)	Return type mismatch
Z518	executor	expected type (Z4), object (Z1), propagated error (Z5)	Object type mismatch
Z519	global	object (Z1)	Undefined list type
Z520	global	object (Z1)	Wrong list type
Z521	global	offending value (Z99)	ZObjects must not be a number or Boolean or null
Z522	global	index of offending element (Z6), propagated error (Z5)	Array element not wellformed
Z523	global	object (Z99)	Missing Z1K1
Z524	global	value (Z99)	Z1K1 must not be a string or array
Z525	global	key (Z6)	Invalid key
Z526	global	key (Z39), propagated error (Z5)	Key value not wellformed
Z527			🆓
Z528			🆓
Z529			🆓
Z530			🆓
Z531	global	object (Z99)	Z6 must have 2 keys
Z532	global	object (Z99)	Z6 without a Z6K1
Z533	global	value of Z6K1 (Z99)	Z6K1 must be a string
Z534	global	object (Z99)	Z9 must have 2 keys
Z535	global	object (Z99)	Z9 without a Z9K1
Z536	global	value of Z9K1 (Z99)	Z9K1 must be a string
Z537	global	value of Z9K1 (Z99)	Z9K1 must look like a reference
Z538	extension	page title (Z6)	Wrong namespace
Z539	extension	page title (Z6)	Wrong content type
Z540	extension	language code (Z6)	Invalid language code
Z541	extension	language code (Z6)	Language code not found
Z542	extension	expected type (Z4), actual type (Z4)	Unexpected ZObject type
Z543	extension	type name (Z6)	Type not found
Z544	extension	type ZID (Z6), type name (Z6), existing type name (Z6)	Conflicting type names
Z545	extension	type ZID (Z6), type name (Z6), existing type ZID (Z6)	Conflicting type ZIDs
Z546	extension	type ZID (Z6), type name (Z6)	Built-in type not found
Z547	global	input (Z99)	Invalid format
Z548	global	error message (Z6), input (Z99)	Invalid JSON
Z549	global	reference value (Z6)	Invalid reference
Z550	global	reference value (Z6)	Unknown reference
Z551	global	key (Z39), expected type (Z6), actual type (Z6)	Schema type mismatch
Z552	global	index of offending element (Z6), expected type (Z4), actual content (Z99)	Array element type mismatch
Z553	global	root zobject (Z99)	Disallowed root type
Z554	extension	clashing ZID (Z6), language (Z6)	Label for a given language clashes with another ZObject's label
Z555	extension	ZID (Z6), page title (Z6)	Unmatching ZID and page title
Z556	extension	title (Z6)	Invalid page title
Z557	extension	message (Z6)	User does not have permission to edit
Z558	global	programming language (Z6)	Invalid programming language
Z559	extension	-	User not permitted to evaluate function
Z560	orchestrator	evaluation result (Z99)	Invalid evaluation result
Z561	evaluator	propagated error (Z5)	Invalid evaluation request
Z562	evaluator	missing property (Z6)	Incomplete evaluation request
Z563	evaluator	call (Z6)	Call by non-reentrant executor
Z564	executor	contents (Z6)	Invalid executor response
Z565	executor	missing property (Z6)	Incomplete executor request
Z566			🆓
Z567			🆓
Z568			🆓
Z569			🆓
Z570	orchestrator	orchestrator rate limit (Z6)	Reached rate limit in orchestrator
Z571	evaluator	evaluator rate limit (Z6)	Reached rate limit in evaluator
Z572	orchestrator	recursion limit (Z6), function name (Z6)	Reached recursion limit in orchestrator
Z573	evaluator	recursion limit (Z6), function name (Z6)	Reached recursion limit in evaluator
Z574	orchestrator	time limit (Z6)	Reached time limit in orchestrator
Z575	evaluator	time limit (Z6)	Reached time limit in evaluator

Erstellung deines eigenen Fehlertyps

Benutzer können auch benutzerdefinierte Fehlertypen definieren, indem sie ein ZObjekt des Typs Z50/Fehlertyp über die Wikifunctions-Benutzeroberfläche oder über die Wikifunctions-API erstellen.

Ein Objekt des Typs Z50/Fehlertyp hat eine ähnliche Form wie ein Z4/Typ und definiert als seinen einzigen Wert (Z50K1) ein Array von Schlüsseln, die eine während der Laufzeit erstellte Instanz dieses Fehlertyps haben muss. Jeder Schlüssel ist eine relevante Information mit einer Bezeichnung, die ihn beschreibt.

Angenommen, wir möchten die Funktion erstellen, die ein als Eingabe übergebenes Datum formatiert. Wenn das Datum falsch ist (z. B. "32.05.1985"), möchten wir einen Fehler "Falsches Datum" zurückgeben, für den wir diesen bestimmten Fehlertyp erstellen werden. Der Typ enthält nur einen Schlüssel, wobei die Darstellung der Zeichenkette des fehlerhaften Datums als Eingabe übergeben wird.

Verwendung der wikilambda_edit-API und Übergabe des folgenden Objekts als zu speichernde Daten:

{
  "Z1K1": "Z2",            // We create a persisted object
  "Z2K1": {                // With Zid Z0, as it will be automatically assigned
    "Z1K1": "Z6",
    "Z6K1": "Z0"
  },
  "Z2K2": {
    "Z1K1": "Z50",
    "Z50K1": [             // One key in the array under Z50K1
      {
        "Z1K1": "Z3",
        "Z3K1": "Z50",
        "Z3K2": "Z0K1",    // The Zid part of the key also is Z0
        "Z3K3": {          // With the label describing the key
          "Z1K1": "Z12",
          "Z12K1": [
            {
              "Z1K1": "Z11",
              "Z11K1": "Z1002",
              "Z11K2": "erroneous date"
            }
          ]
        }
      }
    ]
  },
  "Z2K3": {
    "Z1K1": "Z12",
    "Z12K1": [
      {
        "Z1K1": "Z11",
        "Z11K1": "Z1002",
        "Z11K2": "Incorrect date"    // And a label describing the error
      }
    ]
  }
}

Wenn der Aufruf erfolgreich ist (das Format des Fehlers ist korrekt, die Bezeichnung ist eindeutig, etc.), gibt die API die diesem Fehlertyp zugewiesene ZID zurück.

{
    "wikilambda_edit": {
        "success": "",
        "articleId": 1095,
        "title": "Z10000",
        "page": "Z10000"
    }
}

Meldung eines Fehlers in deiner Implementierung

Es gibt zwei Arten von Funktionsimplementierungen in WikiFunctions, die Benutzern zur Verfügung stehen: solche, die als Programmiersprachencode in einer unterstützten Sprache angegeben sind, und solche, die als Zusammenstellung anderer WikiFunctions-Funktionen angegeben sind. Hier zeigen wir, wie ein Fehler in jeder dieser Arten von Implementierungen ausgelöst wird.

Code

Bei einer Codeimplementierung in einer Programmiersprache kann ein Fehler auf die normale Weise ausgelöst werden, die von dieser Programmiersprache bereitgestellt wird. (Zum Beispiel würde deine Implementierung in Python das Schlüsselwort raise gefolgt von der Spezifikation einer Ausnahme verwenden. In JavaScript würdest du das Schlüsselwort throw verwenden, gefolgt von der Spezifikation einer Ausnahme.) Der WikiFunctions-Systemcode, der für die Ausführung deiner Implementierung verantwortlich ist, fängt die Ausnahme ab und packt sie in ein geeignetes Objekt des Typs Z5/Fehler, das von der Ausführung zurückgegeben wird. (In Python enthält das resultierende Objekt vom Typ Z5/Fehler den Wert von e.args[0], der aus der abgefangenen Ausnahme e extrahiert wurde. In JavaScript enthält es den Wert von e.message, der aus e extrahiert wurde.) Jeder WikiFunctions-Funktionsaufruf gibt ein Objekt vom Typ Z22/Evaluierungsergebnis zurück und das resultierende Objekt vom Typ Z5/Fehler wird als Wert des Schlüssels Z22K2/Metadaten zurückgegeben.

Komposition

In einer Kompositionsimplementierung kann ein Fehler ausgelöst werden, indem ein Z7/Funktionsaufruf an die Funktion Z820/Trigger-Metadaten angegeben und ein Objekt vom Typ Z5/Fehler als Wert des Arguments Z820K1/Fehler dieser Funktion übergeben wird. So sieht ein solcher Aufruf aus, wenn ein Fehler vom Typ Z502/Fehler nicht wohlgeformt angenommen wird:

{ "type": "Function call", "function": "Trigger metadata", "error": { "type": "Error", "error type": "not well-formed error", "error value": { ... } } }

{ "Z1K1": "Z7", "Z7K1": "Z820", "Z820K1": { "Z1K1": "Z5", "Z5K1": "Z502", "Z5K2": { ... } } }

Dein Aufruf von Z820/Trigger-Metadaten bewirkt, dass das angegebene Z5/Fehler-Objekt von der Ausführung der Komposition zurückgegeben wird (als Wert des Schlüssels Z22K2/Metadaten eines Objekts Z22/Evaluierungsergebnis).