fix: resolve OCaml 5.x build errors and warnings

- Rename `effect` type to `eff` (reserved keyword in OCaml 5.x)
  - types.ml, typecheck.ml, unify.ml updated throughout
- Remove deprecated menhir --explain flag from lib/dune
- Fix parser.mly impl_trait_ref double Option wrapping
- Fix resolve.ml comment prematurely closed by `use *)`
- Add missing let* operator to unify.ml
- Remove [@@deriving show] from scope_kind (Hashtbl.pp unbound)
- Fix borrow.ml missing begin/end block for nested match
- Fix test_parser.ml incomplete record patterns and dead code

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Jonathan D.A. Jewell

lib/borrow.ml

@@ -262,9 +262,10 @@ let rec check_expr (state : state) (symbols : Symbol.t) (expr : expr) : unit res
 
   | ExprLet lb ->
     let* () = check_expr state symbols lb.el_value in
-    match lb.el_body with
-    | Some body -> check_expr state symbols body
-    | None -> Ok ()
+    begin match lb.el_body with
+      | Some body -> check_expr state symbols body
+      | None -> Ok ()
+    end
 
   | ExprIf ei ->
     let* () = check_expr state symbols ei.ei_cond in

lib/dune

@@ -7,4 +7,4 @@
 
 (menhir
  (modules parser)
- (flags --explain --table))
+ (flags --table))

lib/parser.mly

@@ -321,7 +321,7 @@ effect_term:
 trait_decl:
   | vis = visibility? TRAIT name = ident type_params = type_params?
     super = supertraits?
-    where_clause = where_clause?
+    _where_clause = where_clause?
     LBRACE items = list(trait_item) RBRACE
     { { trd_vis = Option.value vis ~default:Private;
         trd_name = name;
@@ -368,9 +368,9 @@ impl_block:
         ib_items = items } }
 
 impl_trait_ref:
-  | name = ident FOR { Some { tr_name = name; tr_args = [] } }
+  | name = ident FOR { { tr_name = name; tr_args = [] } }
   | name = ident LBRACKET args = separated_list(COMMA, type_arg) RBRACKET FOR
-    { Some { tr_name = name; tr_args = args } }
+    { { tr_name = name; tr_args = args } }
 
 impl_item:
   | f = fn_decl { ImplFn f }

lib/resolve.ml

@@ -401,7 +401,7 @@ let resolve_program (program : program) : (context, resolve_error * Span.t) Resu
 
 (* TODO: Phase 1 implementation
    - [ ] Module qualified lookups
-   - [ ] Import resolution (use, use as, use *)
+   - [ ] Import resolution (use, use as, use * )
    - [ ] Visibility checking
    - [ ] Forward references in mutual recursion
    - [ ] Type alias expansion during resolution

lib/symbol.ml

@@ -52,7 +52,6 @@ and scope_kind =
   | ScopeBlock
   | ScopeMatch
   | ScopeHandler
-[@@deriving show]
 
 (** The symbol table *)
 type t = {

lib/typecheck.ml

@@ -41,7 +41,7 @@ type context = {
   var_types : (Symbol.symbol_id, scheme) Hashtbl.t;
 
   (** Current effect context *)
-  current_effect : effect;
+  current_effect : eff;
 }
 
 (* Result bind - define before use *)
@@ -214,8 +214,8 @@ and ast_to_ty_arg (ctx : context) (arg : type_arg) : ty =
   | TyArg ty -> ast_to_ty ctx ty
   | NatArg _ -> TNat (NLit 0)  (* TODO: Convert nat expr *)
 
-and ast_to_eff (ctx : context) (eff : effect_expr) : effect =
-  match eff with
+and ast_to_eff (ctx : context) (e : effect_expr) : eff =
+  match e with
   | EffCon (id, _) -> ESingleton id.name
   | EffVar _id -> fresh_effvar ctx.level
   | EffUnion (e1, e2) -> EUnion [ast_to_eff ctx e1; ast_to_eff ctx e2]
@@ -298,7 +298,7 @@ and pattern_span (pat : pattern) : Span.t =
   | PatAs (id, _) -> id.span
 
 (** Synthesize (infer) the type of an expression *)
-let rec synth (ctx : context) (expr : expr) : (ty * effect) result =
+let rec synth (ctx : context) (expr : expr) : (ty * eff) result =
   match expr with
   | ExprVar id ->
     let* ty = lookup_var ctx id in
@@ -502,8 +502,8 @@ let rec synth (ctx : context) (expr : expr) : (ty * effect) result =
   | ExprSpan (e, _span) ->
     synth ctx e
 
-and synth_app (ctx : context) (func_ty : ty) (func_eff : effect)
-    (args : expr list) (span : Span.t) : (ty * effect) result =
+and synth_app (ctx : context) (func_ty : ty) (func_eff : eff)
+    (args : expr list) (span : Span.t) : (ty * eff) result =
   match args with
   | [] -> Ok (func_ty, func_eff)
   | arg :: rest ->
@@ -527,7 +527,7 @@ and synth_app (ctx : context) (func_ty : ty) (func_eff : effect)
     end
 
 (** Check an expression against an expected type *)
-and check (ctx : context) (expr : expr) (expected : ty) : effect result =
+and check (ctx : context) (expr : expr) (expected : ty) : eff result =
   match (expr, repr expected) with
   (* Lambda checking *)
   | (ExprLambda lam, TArrow (param_ty, ret_ty, arr_eff)) ->
@@ -584,13 +584,13 @@ and check (ctx : context) (expr : expr) (expected : ty) : effect result =
   | _ ->
     check_subsumption ctx expr expected
 
-and check_subsumption (ctx : context) (expr : expr) (expected : ty) : effect result =
+and check_subsumption (ctx : context) (expr : expr) (expected : ty) : eff result =
   let* (actual, eff) = synth ctx expr in
   match Unify.unify actual expected with
   | Ok () -> Ok eff
   | Error e -> Error (UnificationFailed (e, expr_span expr))
 
-and synth_list (ctx : context) (exprs : expr list) : ((ty * effect) list) result =
+and synth_list (ctx : context) (exprs : expr list) : ((ty * eff) list) result =
   List.fold_right (fun expr acc ->
     match acc with
     | Error e -> Error e
@@ -600,7 +600,7 @@ and synth_list (ctx : context) (exprs : expr list) : ((ty * effect) list) result
       | Ok result -> Ok (result :: results)
   ) exprs (Ok [])
 
-and check_list (ctx : context) (exprs : expr list) (tys : ty list) : (effect list) result =
+and check_list (ctx : context) (exprs : expr list) (tys : ty list) : (eff list) result =
   List.fold_right2 (fun expr ty acc ->
     match acc with
     | Error e -> Error e
@@ -611,7 +611,7 @@ and check_list (ctx : context) (exprs : expr list) (tys : ty list) : (effect lis
   ) exprs tys (Ok [])
 
 and synth_record_fields (ctx : context) (fields : (ident * expr option) list)
-    : ((string * ty * effect) list) result =
+    : ((string * ty * eff) list) result =
   List.fold_right (fun (id, expr_opt) acc ->
     match acc with
     | Error e -> Error e
@@ -630,7 +630,7 @@ and synth_record_fields (ctx : context) (fields : (ident * expr option) list)
         end
   ) fields (Ok [])
 
-and synth_block (ctx : context) (blk : block) : (ty * effect) result =
+and synth_block (ctx : context) (blk : block) : (ty * eff) result =
   let* effs = List.fold_left (fun acc stmt ->
     let* effs = acc in
     let* eff = synth_stmt ctx stmt in
@@ -643,7 +643,7 @@ and synth_block (ctx : context) (blk : block) : (ty * effect) result =
   | None ->
     Ok (ty_unit, union_eff effs)
 
-and check_block (ctx : context) (blk : block) (expected : ty) : effect result =
+and check_block (ctx : context) (blk : block) (expected : ty) : eff result =
   let* effs = List.fold_left (fun acc stmt ->
     let* effs = acc in
     let* eff = synth_stmt ctx stmt in
@@ -659,7 +659,7 @@ and check_block (ctx : context) (blk : block) (expected : ty) : effect result =
       | Error e -> Error (UnificationFailed (e, Span.dummy))
     end
 
-and synth_stmt (ctx : context) (stmt : stmt) : effect result =
+and synth_stmt (ctx : context) (stmt : stmt) : eff result =
   match stmt with
   | StmtLet sl ->
     let ctx' = enter_level ctx in
@@ -688,7 +688,7 @@ and synth_stmt (ctx : context) (stmt : stmt) : effect result =
     Ok (union_eff [iter_eff; body_eff])
 
 and synth_binop (ctx : context) (left : expr) (op : binary_op) (right : expr)
-    (span : Span.t) : (ty * effect) result =
+    (span : Span.t) : (ty * eff) result =
   let* (left_ty, left_eff) = synth ctx left in
   let* (right_ty, right_eff) = synth ctx right in
   let eff = union_eff [left_eff; right_eff] in
@@ -714,7 +714,7 @@ and synth_binop (ctx : context) (left : expr) (op : binary_op) (right : expr)
       | Error e, _ | _, Error e -> Error (UnificationFailed (e, span))
     end
 
-and synth_unary (ctx : context) (op : unary_op) (operand : expr) : (ty * effect) result =
+and synth_unary (ctx : context) (op : unary_op) (operand : expr) : (ty * eff) result =
   let* (operand_ty, operand_eff) = synth ctx operand in
   match op with
   | OpNeg ->
@@ -822,7 +822,7 @@ and find_field (name : string) (row : row) : ty option =
     else find_field name rest
   | RVar _ -> None
 
-and union_eff (effs : effect list) : effect =
+and union_eff (effs : eff list) : eff =
   let effs = List.filter (fun e -> e <> EPure) effs in
   match effs with
   | [] -> EPure

lib/types.ml

@@ -42,8 +42,8 @@ type ty =
   | TVar of tyvar_state ref          (** Type variable (mutable for unification) *)
   | TCon of string                   (** Type constructor (Int, Bool, etc.) *)
   | TApp of ty * ty list             (** Type application *)
-  | TArrow of ty * ty * effect       (** Function type with effect *)
-  | TDepArrow of string * ty * ty * effect  (** Dependent function type *)
+  | TArrow of ty * ty * eff          (** Function type with effect *)
+  | TDepArrow of string * ty * ty * eff     (** Dependent function type *)
   | TTuple of ty list                (** Tuple type *)
   | TRecord of row                   (** Record type *)
   | TVariant of row                  (** Variant type *)
@@ -75,16 +75,16 @@ and rowvar_state =
 [@@deriving show]
 
 (** Effect type *)
-and effect =
+and eff =
   | EPure                            (** No effects *)
   | EVar of effvar_state ref         (** Effect variable *)
   | ESingleton of string             (** Single effect *)
-  | EUnion of effect list            (** Union of effects *)
+  | EUnion of eff list               (** Union of effects *)
 [@@deriving show]
 
 and effvar_state =
   | EUnbound of effvar * int
-  | ELink of effect
+  | ELink of eff
 [@@deriving show]
 
 (** Type-level natural expression *)
@@ -136,7 +136,7 @@ let fresh_rowvar (level : int) : row =
   next_rowvar := id + 1;
   RVar (ref (RUnbound (id, level)))
 
-let fresh_effvar (level : int) : effect =
+let fresh_effvar (level : int) : eff =
   let id = !next_effvar in
   next_effvar := id + 1;
   EVar (ref (EUnbound (id, level)))
@@ -191,17 +191,17 @@ let rec repr_row (row : row) : row =
   | _ -> row
 
 (** Follow links in an effect *)
-let rec repr_eff (eff : effect) : effect =
-  match eff with
+let rec repr_eff (e : eff) : eff =
+  match e with
   | EVar r ->
     begin match !r with
-      | ELink eff' ->
-        let eff'' = repr_eff eff' in
-        r := ELink eff'';
-        eff''
-      | EUnbound _ -> eff
+      | ELink e' ->
+        let e'' = repr_eff e' in
+        r := ELink e'';
+        e''
+      | EUnbound _ -> e
     end
-  | _ -> eff
+  | _ -> e
 
 (* TODO: Phase 1 implementation
    - [ ] Pretty printing for types

lib/unify.ml

@@ -15,14 +15,17 @@ type unify_error =
   | OccursCheck of tyvar * ty
   | RowMismatch of row * row
   | RowOccursCheck of rowvar * row
-  | EffectMismatch of effect * effect
-  | EffectOccursCheck of effvar * effect
+  | EffectMismatch of eff * eff
+  | EffectOccursCheck of effvar * eff
   | KindMismatch of kind * kind
   | LabelNotFound of string * row
 [@@deriving show]
 
 type 'a result = ('a, unify_error) Result.t
 
+(* Result bind operator *)
+let ( let* ) = Result.bind
+
 (** Check if a type variable occurs in a type (occurs check) *)
 let rec occurs_in_ty (var : tyvar) (ty : ty) : bool =
   match repr ty with
@@ -57,8 +60,8 @@ and occurs_in_row (var : tyvar) (row : row) : bool =
     occurs_in_ty var ty || occurs_in_row var rest
   | RVar _ -> false
 
-and occurs_in_eff (var : tyvar) (eff : effect) : bool =
-  match repr_eff eff with
+and occurs_in_eff (var : tyvar) (e : eff) : bool =
+  match repr_eff e with
   | EPure -> false
   | EVar _ -> false
   | ESingleton _ -> false
@@ -76,8 +79,8 @@ let rec rowvar_occurs_in_row (var : rowvar) (row : row) : bool =
     end
 
 (** Check if an effect variable occurs in an effect *)
-let rec effvar_occurs_in_eff (var : effvar) (eff : effect) : bool =
-  match repr_eff eff with
+let rec effvar_occurs_in_eff (var : effvar) (e : eff) : bool =
+  match repr_eff e with
   | EPure -> false
   | ESingleton _ -> false
   | EVar r ->
@@ -158,7 +161,7 @@ let rec unify (t1 : ty) (t2 : ty) : unit result =
     unify_row r1 r2
 
   (* Forall types *)
-  | (TForall (v1, k1, body1), TForall (v2, k2, body2)) ->
+  | (TForall (_v1, k1, body1), TForall (_v2, k2, body2)) ->
     if k1 <> k2 then
       Error (KindMismatch (k1, k2))
     else
@@ -250,7 +253,7 @@ and unify_row (r1 : row) (r2 : row) : unit result =
     Error (LabelNotFound (l, r2))
 
 (** Unify two effects *)
-and unify_eff (e1 : effect) (e2 : effect) : unit result =
+and unify_eff (e1 : eff) (e2 : eff) : unit result =
   let e1 = repr_eff e1 in
   let e2 = repr_eff e2 in
   match (e1, e2) with

test/test_parser.ml

@@ -48,14 +48,18 @@ let test_literal_string () =
   | _ -> Alcotest.fail "Expected string literal"
 
 let test_literal_bool () =
-  let expr = parse_expr "true" in
-  match expr with
-  | Ast.ExprLit (Ast.LitBool (true, _)) -> ()
-  | _ -> Alcotest.fail "Expected bool literal";
-  let expr = parse_expr "false" in
-  match expr with
-  | Ast.ExprLit (Ast.LitBool (false, _)) -> ()
-  | _ -> Alcotest.fail "Expected bool literal"
+  begin
+    let expr = parse_expr "true" in
+    match expr with
+    | Ast.ExprLit (Ast.LitBool (true, _)) -> ()
+    | _ -> Alcotest.fail "Expected true literal"
+  end;
+  begin
+    let expr = parse_expr "false" in
+    match expr with
+    | Ast.ExprLit (Ast.LitBool (false, _)) -> ()
+    | _ -> Alcotest.fail "Expected false literal"
+  end
 
 let test_literal_unit () =
   let expr = parse_expr "()" in
@@ -200,7 +204,7 @@ let test_match_expr () =
 let test_lambda () =
   let expr = parse_expr "|x| x + 1" in
   match expr with
-  | Ast.ExprLambda { elam_params = [_]; elam_body = _ } -> ()
+  | Ast.ExprLambda { elam_params = [_]; elam_body = _; _ } -> ()
   | _ -> Alcotest.fail "Expected lambda"
 
 let test_block () =
@@ -279,14 +283,14 @@ let test_struct_decl () =
   let prog = parse "struct Point { x: Int, y: Int }" in
   match prog.prog_decls with
   | [Ast.TopType { td_name = { name = "Point"; _ };
-                   td_body = Ast.TyStruct [_; _] }] -> ()
+                   td_body = Ast.TyStruct [_; _]; _ }] -> ()
   | _ -> Alcotest.fail "Expected struct declaration"
 
 let test_enum_decl () =
   let prog = parse "enum Option[T] { Some(T), None }" in
   match prog.prog_decls with
   | [Ast.TopType { td_name = { name = "Option"; _ };
-                   td_body = Ast.TyEnum [_; _] }] -> ()
+                   td_body = Ast.TyEnum [_; _]; _ }] -> ()
   | _ -> Alcotest.fail "Expected enum declaration"
 
 let test_type_alias () =
@@ -298,13 +302,13 @@ let test_type_alias () =
 let test_trait_decl () =
   let prog = parse "trait Eq { fn eq(self: ref Self, other: ref Self) -> Bool; }" in
   match prog.prog_decls with
-  | [Ast.TopTrait { trd_name = { name = "Eq"; _ }; trd_items = [_] }] -> ()
+  | [Ast.TopTrait { trd_name = { name = "Eq"; _ }; trd_items = [_]; _ }] -> ()
   | _ -> Alcotest.fail "Expected trait declaration"
 
 let test_impl_block () =
   let prog = parse "impl Point { fn new(x: Int, y: Int) -> Point { Point { x: x, y: y } } }" in
   match prog.prog_decls with
-  | [Ast.TopImpl { ib_self_ty = _; ib_items = [_] }] -> ()
+  | [Ast.TopImpl { ib_self_ty = _; ib_items = [_]; _ }] -> ()
   | _ -> Alcotest.fail "Expected impl block"
 
 let test_impl_trait () =
@@ -316,7 +320,7 @@ let test_impl_trait () =
 let test_effect_decl () =
   let prog = parse "effect Console { fn print(msg: String) -> (); fn read() -> String; }" in
   match prog.prog_decls with
-  | [Ast.TopEffect { ed_name = { name = "Console"; _ }; ed_ops = [_; _] }] -> ()
+  | [Ast.TopEffect { ed_name = { name = "Console"; _ }; ed_ops = [_; _]; _ }] -> ()
   | _ -> Alcotest.fail "Expected effect declaration"
 
 (* ========== Type Expression Tests ========== *)