Remove uses of let%opt_wrap.

Author: cristianoc

src/ppx/Ppx_Monads.re

@@ -91,28 +91,6 @@ Alternatively, if you are just performing a side effect, and want
 the result of the whole thing to be unit, use `let%consume`.
 |};
 
-let opt_wrap_explanation = {|
-Optional declaration sugar:
-```
-let%opt_wrap name = value;
-otherStuff
-```
-is transformed into
-```
-switch (value) {
-| None => None
-| Some(name) => Some({
-    otherStuff
-  })
-}
-```
-The `wrap` suffix means that the `otherStuff` will be automatically
-wrapped in a `Some`.
-
-If you don't want this wrapping, then use `let%opt`.
-Alternatively, if you are just performing a side effect, and want
-the result of the whole thing to be unit, use `let%consume`.
-|};
 
 let opt_consume_explanation = {|
 Optional declaration sugar:
@@ -143,7 +121,6 @@ let mapper =
         ) as txt, loc}, PStr([{pstr_desc: Pstr_eval({pexp_desc: Pexp_let(Nonrecursive, bindings, continuation)}, _attributes)}]))) => {
         let (front, explanation) = switch (txt) {
           | "opt" => ([%expr Monads.Option.bind], opt_explanation)
-          | "opt_wrap" => ([%expr Monads.Option.map], opt_wrap_explanation)
           | "opt_consume" => ([%expr Monads.Option.consume], opt_consume_explanation)
           | "try" => ([%expr Monads.Result.bind], "Sugar for the Result type")
           | "try_wrap" => ([%expr Monads.Result.map], "Sugar for the Result type - auto-wraps in `Ok()`")

src/rescript-editor-support/MessageHandlers.re

@@ -77,29 +77,28 @@ let handlers:
       let%try (uri, pos) = Protocol.rPositionParams(params);
       let%try package = getPackage(uri, state);
 
-      let res =
-        {
-          let pos = Utils.cmtLocFromVscode(pos);
-          let%opt (file, extra) =
-            State.fileForUri(state, ~package, uri) |> toOptionAndLog;
-
-          let%opt_wrap refs = References.refsForPos(~file, ~extra, pos);
-          (
-            state,
-            J.l(
-              refs
-              |> List.map(loc =>
-                   J.o([
-                     ("range", Protocol.rangeOfLoc(loc)),
-                     ("kind", J.i(2)),
-                   ])
-                 ),
-            ),
-          );
-        }
-        |? (state, Json.Null);
-
-      Ok(res);
+      let pos = Utils.cmtLocFromVscode(pos);
+      let refs =
+        switch (State.fileForUri(state, ~package, uri) |> toOptionAndLog) {
+        | None => None
+        | Some((file, extra)) => References.refsForPos(~file, ~extra, pos)
+        };
+      Ok((
+        state,
+        switch (refs) {
+        | None => J.null
+        | Some(refs) =>
+          J.l(
+            refs
+            |> List.map(loc =>
+                 J.o([
+                   ("range", Protocol.rangeOfLoc(loc)),
+                   ("kind", J.i(2)),
+                 ])
+               ),
+          )
+        },
+      ));
     },
   ),
   (

src/rescript-editor-support/Monads.re

@@ -1,18 +1,5 @@
-
-module type MonadThing = {
-  type t('a);
-  let map: (t('a), ~f: 'a => 'b) => t('b);
-  let bind: (t('a), ~f: 'a => t('b)) => t('b);
-  let consume: (t('a), ~f: 'a => unit) => unit;
-};
-
 module Option = {
   type t('a) = option('a);
-  let map = (value, ~f as use) =>
-    switch (value) {
-    | Some(x) => Some(use(x))
-    | None => None
-    };
   let bind = (value, ~f as use) =>
     switch (value) {
     | Some(x) => use(x)
@@ -25,7 +12,7 @@ module Option = {
     };
 };
 
-module O: MonadThing = Option;
+module O = Option;
 
 module Result = {
   let map /*: t 'a 'b => f::('a => 'c) => t 'c 'b*/ = (value, ~f as use) =>

src/rescript-editor-support/NewCompletions.re

@@ -512,14 +512,13 @@ let getItems =
 
     switch (determineCompletion(multiple)) {
     | `Normal(path) =>
-      {
-        Log.log("normal " ++ pathToString(path));
-        let%opt_wrap (env, suffix) =
-          getEnvWithOpens(~pos, ~env, ~getModule, ~opens, path);
+      Log.log("normal " ++ pathToString(path));
+      switch (getEnvWithOpens(~pos, ~env, ~getModule, ~opens, path)) {
+      | Some((env, suffix)) =>
         Log.log("Got the env");
         valueCompletions(~env, suffix);
-      }
-      |? []
+      | None => []
+      };
     | `Attribute(target, suffix) =>
       {
         Log.log("suffix :" ++ suffix);
@@ -573,16 +572,14 @@ let getItems =
       }
       |? []
     | `AbsAttribute(path) =>
-      {
-        let%opt_wrap (env, suffix) =
-          getEnvWithOpens(~pos, ~env, ~getModule, ~opens, path);
-
+      switch (getEnvWithOpens(~pos, ~env, ~getModule, ~opens, path)) {
+      | None => []
+      | Some((env, suffix)) =>
         attributeCompletions(~env, ~suffix)
         @ List.concat(
             opens |> List.map(env => attributeCompletions(~env, ~suffix)),
-          );
+          )
       }
-      |? []
     };
   };
 };

src/rescript-editor-support/ProcessExtra.re

@@ -62,16 +62,20 @@ let getTypeAtPath = (~env, path) => {
   | `Exported(env, name) =>
     let res = {
       let%opt stamp = Hashtbl.find_opt(env.exported.types, name);
-      let%opt_wrap declaredType =
-        Hashtbl.find_opt(env.file.stamps.types, stamp);
-      `Local(declaredType);
+      let declaredType = Hashtbl.find_opt(env.file.stamps.types, stamp);
+      switch (declaredType) {
+      | Some(declaredType) => Some(`Local(declaredType))
+      | None => None
+      };
     };
     res |? `Not_found;
   | `Stamp(stamp) =>
     let res = {
-      let%opt_wrap declaredType =
-        Hashtbl.find_opt(env.file.stamps.types, stamp);
-      `Local(declaredType);
+      let declaredType = Hashtbl.find_opt(env.file.stamps.types, stamp);
+      switch (declaredType) {
+      | Some(declaredType) => Some(`Local(declaredType))
+      | None => None
+      };
     };
     res |? `Not_found;
   };
@@ -141,12 +145,12 @@ module F =
         addExternalReference(moduleName, path, tip, identLoc);
         GlobalReference(moduleName, path, tip);
       | `Exported(env, name) =>
-        let res = {
-          let%opt_wrap stamp = Hashtbl.find_opt(env.exported.values, name);
+        switch (Hashtbl.find_opt(env.exported.values, name)) {
+        | Some(stamp) =>
           addReference(stamp, identLoc);
           LocalReference(stamp, tip);
-        };
-        res |? NotFound;
+        | None => NotFound
+        }
       | `GlobalMod(_) => NotFound
       };
     addLocation(loc, Typed(typ, locType));
@@ -166,12 +170,12 @@ module F =
         addExternalReference(moduleName, path, Module, loc);
         LModule(GlobalReference(moduleName, path, Module));
       | `Exported(env, name) =>
-        let res = {
-          let%opt_wrap stamp = Hashtbl.find_opt(env.exported.modules, name);
+        switch (Hashtbl.find_opt(env.exported.modules, name)) {
+        | Some(stamp) =>
           addReference(stamp, loc);
           LModule(LocalReference(stamp, Module));
-        };
-        res |? LModule(NotFound);
+        | None => LModule(NotFound)
+        }
       };
     addLocation(loc, locType);
   };
@@ -189,13 +193,12 @@ module F =
       let locType =
         switch (t) {
         | `Local({stamp, item: {kind: Record(attributes)}}) =>
-          {
-            let%opt_wrap {stamp: astamp} =
-              attributes |> List.find_opt(a => a.aname.txt == name);
+          switch (attributes |> List.find_opt(a => a.aname.txt == name)) {
+          | Some({stamp: astamp}) =>
             addReference(astamp, nameLoc);
             LocalReference(stamp, Attribute(name));
+          | None => NotFound
           }
-          |? NotFound
         | `Global(moduleName, path) =>
           addExternalReference(moduleName, path, Attribute(name), nameLoc);
           GlobalReference(moduleName, path, Attribute(name));
@@ -221,13 +224,12 @@ module F =
            let locType =
              switch (t) {
              | `Local({stamp, item: {kind: Record(attributes)}}) =>
-               {
-                 let%opt_wrap {stamp: astamp} =
-                   attributes |> List.find_opt(a => a.aname.txt == name);
+               switch (attributes |> List.find_opt(a => a.aname.txt == name)) {
+               | Some({stamp: astamp}) =>
                  addReference(astamp, nameLoc);
                  LocalReference(stamp, Attribute(name));
+               | None => NotFound
                }
-               |? NotFound
              | `Global(moduleName, path) =>
                addExternalReference(
                  moduleName,
@@ -258,13 +260,12 @@ module F =
       let locType =
         switch (t) {
         | `Local({stamp, item: {kind: Variant(constructors)}}) =>
-          {
-            let%opt_wrap {stamp: cstamp} =
-              constructors |> List.find_opt(c => c.cname.txt == cstr_name);
+          switch (constructors |> List.find_opt(c => c.cname.txt == cstr_name)) {
+          | Some({stamp: cstamp}) =>
             addReference(cstamp, nameLoc);
             LocalReference(stamp, Constructor(name));
+          | None => NotFound
           }
-          |? NotFound
         | `Global(moduleName, path) =>
           addExternalReference(moduleName, path, Constructor(name), nameLoc);
           GlobalReference(moduleName, path, Constructor(name));

src/rescript-editor-support/Query.re

@@ -148,16 +148,16 @@ let fromCompilerPath = (~env, path) => {
   | `Path(0, moduleName, path) => `Global((moduleName, path))
   | `GlobalMod(name) => `GlobalMod(name)
   | `Path(stamp, _moduleName, path) =>
-    let res = {
-      let%opt {item: kind} =
-        Hashtbl.find_opt(env.file.stamps.modules, stamp);
-      let%opt_wrap res = findInModule(~env, kind, path);
-      switch (res) {
-      | `Local(env, name) => `Exported((env, name))
-      | `Global(moduleName, fullPath) => `Global((moduleName, fullPath))
+    let res =
+      switch (Hashtbl.find_opt(env.file.stamps.modules, stamp)) {
+      | None => None
+      | Some({item: kind}) => findInModule(~env, kind, path)
       };
+    switch (res) {
+    | None => `Not_found
+    | Some(`Local(env, name)) => `Exported((env, name))
+    | Some(`Global(moduleName, fullPath)) => `Global((moduleName, fullPath))
     };
-    res |? `Not_found;
   };
 };
 
@@ -188,13 +188,18 @@ let resolveModuleFromCompilerPath = (~env, ~getModule, path) => {
 let resolveFromCompilerPath = (~env, ~getModule, path) => {
   switch (fromCompilerPath(~env, path)) {
   | `Global(moduleName, path) =>
-    let res = {
-      let%opt file = getModule(moduleName);
-      let env = {file, exported: file.contents.exported};
-      let%opt_wrap (env, name) = resolvePath(~env, ~getModule, ~path);
-      `Exported((env, name));
+    let res =
+      switch (getModule(moduleName)) {
+      | None => None
+      | Some(file) =>
+        let env = {file, exported: file.contents.exported};
+        resolvePath(~env, ~getModule, ~path);
+      };
+    switch (res) {
+    | None => `Not_found
+    | Some((env, name)) => `Exported((env, name))
     };
-    res |? `Not_found;
+
   | `Stamp(stamp) => `Stamp(stamp)
   | `GlobalMod(_) => `Not_found
   | `Not_found => `Not_found

src/rescript-editor-support/References.re

@@ -70,12 +70,16 @@ let localReferencesForLoc = (~file, ~extra, loc) =>
     Hashtbl.find_opt(extra.internalReferences, localStamp);
   | LModule(GlobalReference(moduleName, path, tip))
   | Typed(_, GlobalReference(moduleName, path, tip)) =>
-    let%opt_wrap refs =
-      Hashtbl.find_opt(extra.externalReferences, moduleName);
-    refs
-    |> Utils.filterMap(((p, t, l)) =>
-         p == path && t == tip ? Some(l) : None
-       );
+    switch (Hashtbl.find_opt(extra.externalReferences, moduleName)) {
+    | None => None
+    | Some(refs) =>
+      Some(
+        refs
+        |> Utils.filterMap(((p, t, l)) =>
+             p == path && t == tip ? Some(l) : None
+           ),
+      )
+    }
   };
 
 let definedForLoc = (~file, ~getModule, loc) => {

src/rescript-editor-support/State.re

@@ -299,8 +299,10 @@ let docsForModule = (modname, state, ~package) =>
     let src = SharedTypes.getSrc(paths);
     Log.log("FINDING docs for module " ++ SharedTypes.showPaths(paths));
     Log.log("FINDING " ++ cmt ++ " src " ++ (src |? ""));
-    let%opt_wrap docs = docsForCmt(~moduleName=modname, cmt, src, state);
-    (docs, src);
+    switch (docsForCmt(~moduleName=modname, cmt, src, state)) {
+    | None => None
+    | Some(docs) => Some((docs, src))
+    };
   } else {
     Log.log("No path for module " ++ modname);
     None;