chore(compiler): Prefer option over exception Not_found where possible in compiler helpers.

compiler/src/codegen/comp_wasm_prim.re

@@ -146,9 +146,9 @@ let op_map = {
 };
 
 let get_op = name =>
-  try(OpHash.find(op_map, name)) {
-  | Not_found =>
-    failwith(Printf.sprintf("internal: Wasm instruction not registered"))
+  switch (OpHash.find_opt(op_map, name)) {
+  | Some(op) => op
+  | None => failwith("internal: Wasm instruction not registered")
   };
 
 let compile_wasm_prim1 = (wasm_mod, env, instr, ret_type, arg) => {

compiler/src/codegen/concatlist.re

@@ -135,14 +135,14 @@ let rec rev = cl =>
 let rec hd = cl =>
   switch (cl) {
   | Singleton(e)
-  | Cons(e, _) => e
-  | Snoc(l, e) when is_empty(l) => e
+  | Cons(e, _) => Some(e)
+  | Snoc(l, e) when is_empty(l) => Some(e)
   | Snoc(l, _) => hd(l)
   | Append(l1, _) when !is_empty(l1) => hd(l1)
   | Append(_, l2) => hd(l2)
-  | Wrapped([hd, ..._]) => hd
+  | Wrapped([hd, ..._]) => Some(hd)
   | Wrapped([])
-  | Empty => raise(Not_found)
+  | Empty => None
   };
 
 let rec tl = cl =>

compiler/src/codegen/concatlist.rei

@@ -47,15 +47,11 @@ let rev: t('a) => t('a);
 
 /** Returns the first element of the given concatlist. If the list has
     no elements, [Failure "hd"] is raised. */
-/** Returns all but the first element of the given concatlist. If the list has no tail,
-    [Failure "tl"] is raised. */
 
-let hd: t('a) => 'a;
+let hd: t('a) => option('a);
 
 /** Returns all but the first element of the given concatlist. If the list has no tail,
     [Failure "tl"] is raised. */
-/** Returns the last element of the given concatlist. If the list has no tail,
-    [Failure "last"] is raised. */
 
 let tl: t('a) => t('a);
 

compiler/src/codegen/transl_anf.re

@@ -156,20 +156,19 @@ let get_stack_size = () => {
 };
 
 let find_id = (id, env) =>
-  try(Ident.find_same(id, env.ce_binds)) {
-  | Not_found =>
-    let alloc = Ident.find_same(id, global_table^);
-    MGlobalBind(global_name(id), alloc);
+  switch (Ident.find_same_opt(id, env.ce_binds)) {
+  | Some(v) => v
+  | None =>
+    switch (Ident.find_same_opt(id, global_table^)) {
+    | Some(alloc) => MGlobalBind(global_name(id), alloc)
+    | None => raise(Not_found)
+    }
   };
 
 let worklist_reset = () => Queue.clear(compilation_worklist);
 let worklist_enqueue = elt => Queue.add(elt, compilation_worklist);
 let worklist_empty = () => Queue.is_empty(compilation_worklist);
-let worklist_pop = () =>
-  switch (Queue.take_opt(compilation_worklist)) {
-  | None => raise(Not_found)
-  | Some(hd) => hd
-  };
+let worklist_pop = () => Queue.take_opt(compilation_worklist);
 
 let wasm_import_name = (mod_, name) =>
   Printf.sprintf("wimport_%s_%s", mod_, name);
@@ -734,14 +733,11 @@ let compile_worklist_elt = ({body, env}: worklist_elt) =>
   | Precompiled(block, stack_size) => (block, stack_size)
   };
 
-let fold_left_pop = (f, base) => {
-  let rec help = acc =>
-    if (worklist_empty()) {
-      acc;
-    } else {
-      help(f(acc, worklist_pop()));
-    };
-  help(base);
+let rec fold_left_pop = (f, base) => {
+  switch (worklist_pop()) {
+  | None => base
+  | Some(elt) => fold_left_pop(f, f(base, elt))
+  };
 };
 
 let compile_remaining_worklist = () => {

compiler/src/language_server/hover.re

@@ -124,15 +124,18 @@ let declaration_lens = (ident: Ident.t, decl: Types.type_declaration) => {
 
 let include_lens = (env: Env.t, path: Path.t) => {
   let header = grain_code_block("module " ++ Path.name(path));
-  let decl = Env.find_module(path, None, env);
-  let module_decl =
-    switch (Modules.get_provides(decl)) {
-    | [_, ..._] => Some(module_lens(decl))
-    | [] => None
+  switch (Env.find_module_opt(path, None, env)) {
+  | Some(decl) =>
+    let module_decl =
+      switch (Modules.get_provides(decl)) {
+      | [_, ..._] => Some(module_lens(decl))
+      | [] => None
+      };
+    switch (module_decl) {
+    | Some(mod_sig) => Some(markdown_join(header, mod_sig))
+    | None => Some(header)
     };
-  switch (module_decl) {
-  | Some(mod_sig) => markdown_join(header, mod_sig)
-  | None => header
+  | None => None
   };
 };
 
@@ -188,10 +191,7 @@ let process =
     | [Module({decl, loc}), ..._] =>
       send_hover(~id, ~range=Utils.loc_to_range(loc), module_lens(decl))
     | [Include({path, loc}), ..._] =>
-      let hover_lens =
-        try(Some(include_lens(program.env, path))) {
-        | Not_found => None
-        };
+      let hover_lens = include_lens(program.env, path);
       switch (hover_lens) {
       | Some(lens) => send_hover(~id, ~range=Utils.loc_to_range(loc), lens)
       | None => send_no_result(~id)

compiler/src/language_server/sourcetree.re

@@ -531,8 +531,8 @@ module Sourcetree: Sourcetree = {
           switch (stmt.ttop_desc) {
           | TTopModule(decl) =>
             let path = Path.PIdent(decl.tmod_id);
-            try({
-              let mod_decl = Env.find_module(path, None, stmt.ttop_env);
+            switch (Env.find_module_opt(path, None, stmt.ttop_env)) {
+            | Some(mod_decl) =>
               segments :=
                 [
                   (
@@ -545,9 +545,8 @@ module Sourcetree: Sourcetree = {
                     }),
                   ),
                   ...segments^,
-                ];
-            }) {
-            | Not_found => ()
+                ]
+            | None => ()
             };
           | TTopInclude(inc) =>
             segments :=

compiler/src/middle_end/optimize_constants.re

@@ -41,14 +41,12 @@ module ConstantPropagationArg: Anf_mapper.MapArgument = {
   let leave_imm_expression = ({imm_desc: desc} as i) =>
     switch (desc) {
     | ImmId(id) =>
-      try({
-        let value = Ident.find_same(id, known_constants^);
-        {
+      switch (Ident.find_same_opt(id, known_constants^)) {
+      | Some(value) => {
           ...i,
           imm_desc: value,
-        };
-      }) {
-      | Not_found => i
+        }
+      | None => i
       }
     | _ => i
     };

compiler/src/parsing/identifier.re

@@ -55,11 +55,12 @@ let last =
   | IdentExternal(_, s) => s.txt;
 
 let rec split_at_dots = (s, pos) =>
-  try({
-    let dot = String.index_from(s, pos, '.');
-    [String.sub(s, pos, dot - pos), ...split_at_dots(s, dot + 1)];
-  }) {
-  | Not_found => [String.sub(s, pos, String.length(s) - pos)]
+  switch (String.index_from_opt(s, pos, '.')) {
+  | Some(dot) => [
+      String.sub(s, pos, dot - pos),
+      ...split_at_dots(s, dot + 1),
+    ]
+  | None => [String.sub(s, pos, String.length(s) - pos)]
   };
 
 let flatten = n => {