Improve the error handling situation (#71)

* Sketches of a condition system

* `Condition.condition` -> `Condition.t`

* Migrate `NT` over

* Migrate `Branch` over

* Migrate `Sublanguage` et al. over

* Migrate the PRL over

* Migrate the DRL over

* Migrate the DML over

* Have `Qualified_name.try_parse` return a `Condition.t`

* Migrate the DDL over

* Migrate the VCL over

* Migrate the SCL over

* Migrate the ICL over

* Migrate the parsers over

* Just inherit the errors from NT and the sublanguages

* Migrate `Management.Physical` over

* Migrate `Configuration` over

* Migrate `Management.Branch` over

* Migrate `Transport` over

* Migrate `System` over

* Migrate `Server` over

* Include messages on on all conditions

* A prettier stringifier

3 files changed, 16 insertions, 25 deletions

diff --git a/lib/scl/executor.ml b/lib/scl/executor.ml
index 6848091..e40fde6 100644
--- a/lib/scl/executor.ml
+++ b/lib/scl/executor.ml
@@ -13,28 +13,22 @@ type exec_result =
 module Make (NT : Nt.S) = struct
   module DrlExec = Drl.Executor.Make (NT)
 
-  type error =
-    | ParseError of string
-    | QueryError of DrlExec.error
-    | CursorError of string
-
-  let sexp_of_error e =
-    let open Sexplib.Sexp in
-    match e with
-    | ParseError s -> List [ Atom "parse-error"; Atom s ]
-    | QueryError e -> DrlExec.sexp_of_error e
-    | CursorError s -> List [ Atom "cursor-error"; Atom s ]
+  module Error = struct
+    open Condition
+    (* TODO: more structure *)
+    let cursor_error msg = condition "cursor-error" msg empty
+  end
 
   let ( let* ) = Result.bind
 
   let execute (ctx : Sublanguage_context.t) (stmt : Ast.statement) :
-      (exec_result, error) result =
+      (exec_result, Condition.t) result =
     ignore default_batch;
     match stmt with
     | Ast.Begin _ ->
-        Error (CursorError "cursors not yet implemented")
+        Error (Error.cursor_error "cursors not yet implemented")
     | Ast.Fetch _ ->
-        Error (CursorError "cursors not yet implemented")
+        Error (Error.cursor_error "cursors not yet implemented")
     | Ast.Close _ ->
         let* () = Ok () in
         Ok (Closed ctx.branch#multigroups)
diff --git a/lib/scl/parser.ml b/lib/scl/parser.ml
index 3e9c4ed..53719ee 100644
--- a/lib/scl/parser.ml
+++ b/lib/scl/parser.ml
@@ -1,19 +1,22 @@
-type error = ParseError of string
+module Error = struct
+  open Condition
+  let parse_error msg = condition "parse-error" msg empty
+end
 
 let validate = function
   | (Ast.Begin { limit = Some limit; _ } | Ast.Fetch { limit = Some limit; _ })
     when limit <= 0 ->
-      Error (ParseError "The provision of `limit` is expected to be positive.")
+      Error (Error.parse_error "The provision of `limit` is expected to be positive.")
   | stmt -> Ok stmt
 
 let of_sexp sexp =
   match Ast.statement_of_sexp sexp with
-  | exception exn -> Error (ParseError (Printexc.to_string exn))
+  | exception exn -> Error (Error.parse_error (Printexc.to_string exn))
   | stmt -> validate stmt
 
 let of_string s =
   match Sexplib.Sexp.of_string s |> Ast.statement_of_sexp with
-  | exception exn -> Error (ParseError (Printexc.to_string exn))
+  | exception exn -> Error (Error.parse_error (Printexc.to_string exn))
   | stmt -> validate stmt
 
 let to_string stmt = Ast.sexp_of_statement stmt |> Sexplib.Sexp.to_string_hum
diff --git a/lib/scl/sublanguage.ml b/lib/scl/sublanguage.ml
index 87e4d42..0793211 100644
--- a/lib/scl/sublanguage.ml
+++ b/lib/scl/sublanguage.ml
@@ -3,15 +3,11 @@ module Make (NT : Nt.S) = struct
 
   type configuration = unit
   type ast = Ast.statement
-  type error = Exec.error
 
   let name = "scl"
   let parse _ = Ok ()
 
-  let parse_sexp sexp =
-    match Parser.of_sexp sexp with
-    | Ok r -> Ok r
-    | Error (Parser.ParseError s) -> Error (Exec.ParseError s)
+  let parse_sexp sexp = Parser.of_sexp sexp
 
   let execute ctx ast =
     Exec.execute ctx ast
@@ -19,6 +15,4 @@ module Make (NT : Nt.S) = struct
          | Executor.Batch { cursor_id; rows; has_more } ->
              Sublanguage_types.Cursor { cursor_id; rows; has_more }
          | Executor.Closed delta -> Sublanguage_types.Transition delta)
-
-  let sexp_of_error = Exec.sexp_of_error
 end