more

lib/htmlrw_check/attr_utils.ml

···
   match get_attr name attrs with
   | Some v -> String.trim v <> ""
   | None -> false
+
+(** Create a unit hashtable from a list of keys for O(1) membership testing. *)
+let hashtbl_of_list items =
+  let tbl = Hashtbl.create (List.length items) in
+  List.iter (fun x -> Hashtbl.add tbl x ()) items;
+  tbl
+
+(** Check a list of attributes and report errors for any that are present. *)
+let check_disallowed_attrs ~element ~collector ~attrs disallowed =
+  List.iter (fun attr ->
+    if has_attr attr attrs then
+      Message_collector.add_typed collector
+        (`Attr (`Not_allowed (`Attr attr, `Elem element)))
+  ) disallowed

lib/htmlrw_check/attr_utils.mli

···
     @param name The attribute name to look for (lowercase)
     @param attrs The attribute list
     @return [true] if the attribute exists and has a non-empty value *)
+
+(** {1 Utility Functions} *)
+
+val hashtbl_of_list : 'a list -> ('a, unit) Hashtbl.t
+(** [hashtbl_of_list items] creates a hashtable for O(1) membership testing.
+
+    @param items List of keys to add
+    @return A hashtable where each item maps to unit *)
+
+val check_disallowed_attrs :
+  element:string ->
+  collector:Message_collector.t ->
+  attrs:attrs ->
+  string list ->
+  unit
+(** [check_disallowed_attrs ~element ~collector ~attrs disallowed] reports
+    errors for any disallowed attributes that are present.
+
+    This is a convenience function to reduce repetitive attribute checking
+    code in checkers.
+
+    @param element The element name for error messages
+    @param collector The message collector
+    @param attrs The attribute list to check
+    @param disallowed List of attribute names that are not allowed *)

lib/htmlrw_check/checker.ml

···
     | Some f -> f
     | None -> fun _ _ -> ()
 end
+
+(** Create a checker from individual callback functions.
+    This eliminates the boilerplate module wrapper at the end of each checker. *)
+let make
+    (type s)
+    ~(create : unit -> s)
+    ~(reset : s -> unit)
+    ~(start_element : s -> element:Element.t -> Message_collector.t -> unit)
+    ~(end_element : s -> tag:Tag.element_tag -> Message_collector.t -> unit)
+    ?(characters : (s -> string -> Message_collector.t -> unit) option)
+    ?(end_document : (s -> Message_collector.t -> unit) option)
+    () : t =
+  (module struct
+    type state = s
+    let create = create
+    let reset = reset
+    let start_element = start_element
+    let end_element = end_element
+    let characters = match characters with
+      | Some f -> f
+      | None -> fun _ _ _ -> ()
+    let end_document = match end_document with
+      | Some f -> f
+      | None -> fun _ _ -> ()
+  end : S)

lib/htmlrw_check/checker.mli

···
     ]}
 *)
 module Make : functor (I : Input) -> S with type state = I.state
+
+(** Create a checker from individual callback functions.
+
+    This is a simpler alternative to the [Make] functor that eliminates the
+    need for a module wrapper at the end of each checker file.
+
+    {b Example:}
+    {[
+      let checker = Checker.make
+        ~create:(fun () -> { count = 0 })
+        ~reset:(fun s -> s.count <- 0)
+        ~start_element:(fun s ~element collector -> ...)
+        ~end_element:(fun s ~tag collector -> ...)
+        ()
+    ]}
+
+    @param create State initialization function
+    @param reset State reset function
+    @param start_element Element start callback
+    @param end_element Element end callback
+    @param characters Optional text content callback (default: no-op)
+    @param end_document Optional document end callback (default: no-op)
+*)
+val make :
+  create:(unit -> 's) ->
+  reset:('s -> unit) ->
+  start_element:('s -> element:Element.t -> Message_collector.t -> unit) ->
+  end_element:('s -> tag:Tag.element_tag -> Message_collector.t -> unit) ->
+  ?characters:('s -> string -> Message_collector.t -> unit) ->
+  ?end_document:('s -> Message_collector.t -> unit) ->
+  unit ->
+  t

lib/htmlrw_check/content_model/content_checker.ml

···
     state.ancestor_stack
 
 (* Package as first-class module *)
-let checker =
-  (module struct
-    type nonrec state = state
-
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ~end_document ()

lib/htmlrw_check/content_model/content_checker.mli

···
     2. Checking each child element or text node against the content model
     3. Tracking the ancestor stack to detect prohibited relationships
     4. Emitting appropriate errors or warnings for violations
-
-    {2 Usage Example}
-
-    {[
-      let checker = Content_checker.create (Message_collector.create ()) in
-      let module C = (val checker : Checker.S) in
-      let state = C.create () in
-
-      (* Walk the DOM tree *)
-      C.start_element state ~name:"div" ~namespace:None ~attrs:[] collector;
-      C.characters state "Hello, world!" collector;
-      C.end_element state ~name:"div" ~namespace:None collector;
-      C.end_document state collector
-    ]}
 *)
-
-(** Include the standard checker signature. *)
-include Checker.S
-
-(** {1 Creation} *)
-
-val create_with_registry : ?registry:Element_registry.t -> Message_collector.t -> state
-(** [create_with_registry ?registry collector] creates a content checker with an
-    optional custom element registry.
-
-    If no registry is provided, uses {!Element_registry.default}.
-
-    @param registry Custom element registry (defaults to standard HTML5 elements)
-    @param collector Message collector for validation messages *)
-
-(** {1 First-Class Module} *)
 
 val checker : Checker.t
 (** [checker] is the content checker packaged as a first-class module.

lib/htmlrw_check/semantic/autofocus_checker.ml

···
 
   state.current_depth <- state.current_depth - 1
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/semantic/form_checker.ml

···
     checks (like button-outside-form and label references) don't match
     Nu validator's behavior. *)
 
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 
···
 
 let end_element _state ~tag:_ _collector = ()
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker = (module struct
-  type nonrec state = state
-
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/semantic/form_checker.mli

···
     @see <https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html>
          WCAG: Labels or Instructions *)
 
-include Checker.S
-
 val checker : Checker.t
 (** A first-class module instance of this checker.
 

lib/htmlrw_check/semantic/id_checker.ml

···
       | _ -> ())
    | _ -> ())
 
-let end_element _state ~tag:_ _collector =
-  ()
-
-let characters _state _text _collector =
-  ()
+let end_element _state ~tag:_ _collector = ()
 
 let end_document state collector =
   (* Check all ID references point to existing IDs *)
···
             (Error_code.q ref.attribute) (Error_code.q ref.referring_element) (Error_code.q ref.referenced_id)))
   ) state.usemap_references
 
-let checker = (module struct
-  type nonrec state = state
-
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~end_document ()

lib/htmlrw_check/semantic/id_checker.mli

···
     - ID references (for, headers, aria-*, etc.) point to existing IDs
     - ID values conform to HTML5 requirements *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating ID uniqueness and references. *)

lib/htmlrw_check/semantic/lang_detecting_checker.ml

···
     | _ -> ()
   end
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ~end_document ()

lib/htmlrw_check/semantic/nesting_checker.ml

···
       end
   | _ -> ()
 
-let characters _state _text _collector =
-  ()  (* No text-specific nesting checks *)
-
-let end_document _state _collector =
-  ()  (* No document-level checks needed *)
-
 (** Create the checker as a first-class module. *)
-let checker =
-  let module M = struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end in
-  (module M : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/semantic/nesting_checker.mli

···
          HTML5 specification: Content models
 *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating element nesting rules. *)

lib/htmlrw_check/semantic/obsolete_checker.ml

···
   | Tag.Html `Head -> state.in_head <- false
   | _ -> ()
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker =
-  let module M = struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end in
-  (module M : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/semantic/obsolete_checker.mli

···
     ]}
 *)
 
-(** Include the standard checker signature. *)
-include Checker.S
-
-(** {1 Checker Instance} *)
-
 val checker : Checker.t
 (** [checker] is a pre-configured obsolete checker instance that can be
     registered with the checker registry.

lib/htmlrw_check/semantic/option_checker.ml

···
     | [] -> ()
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/semantic/required_attr_checker.ml

···
   | Tag.Html `A -> state.in_a_with_href <- false
   | _ -> ()
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker = (module struct
-  type nonrec state = state
-
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/semantic/required_attr_checker.mli

···
     @see <https://html.spec.whatwg.org/multipage/indices.html#attributes-3>
          WHATWG HTML: Attributes *)
 
-include Checker.S
-
 val checker : Checker.t
 (** A first-class module instance of this checker.
 

lib/htmlrw_check/specialized/aria_checker.ml

···
        | [] -> ()) (* Stack underflow - shouldn't happen in well-formed docs *)
   | _ -> ()
 
-let characters _state _text _collector = ()
-
 let end_document state collector =
   (* Check that active tabs have corresponding tabpanels *)
   if state.has_active_tab && not state.has_tabpanel then
···
   if state.visible_main_count > 1 then
     Message_collector.add_typed collector (`Aria `Multiple_main)
 
-let checker = (module struct
-  type nonrec state = state
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~end_document ()

lib/htmlrw_check/specialized/aria_checker.mli

···
          WAI-ARIA 1.2 specification
 *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating ARIA roles and attributes. *)

lib/htmlrw_check/specialized/attr_restrictions_checker.ml

···
   | _ -> () (* Skip non-HTML elements *)
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/base_checker.ml

···
   | _ -> ()
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/datetime_checker.ml

···
       end
 
 (** Checker state *)
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 let reset _state = ()
···
   | _ -> ()  (* Non-HTML elements don't have datetime attributes *)
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/dl_checker.ml

···
     end
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/h1_checker.ml

···
     state.svg_depth <- state.svg_depth - 1
   | _ -> ()
 
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/heading_checker.ml

···
     Message_collector.add_typed collector
       (`Generic "Document contains no heading elements (h1-h6). Headings provide important document structure for accessibility")
 
-let checker = (module struct
-  type nonrec state = state
-
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ~end_document ()

lib/htmlrw_check/specialized/heading_checker.mli

···
     - Multiple h1 usage patterns
     - Headings should not be empty *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating heading structure. *)

lib/htmlrw_check/specialized/importmap_checker.ml

···
   if state.in_importmap then
     Buffer.add_string state.content text
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/label_checker.ml

···
 (** Labelable elements that label can reference *)
 let labelable_elements = ["button"; "input"; "meter"; "output"; "progress"; "select"; "textarea"]
 
-(** Helper to get attribute value *)
-let get_attr attrs name =
-  let name_lower = String.lowercase_ascii name in
-  List.find_map (fun (n, v) ->
-    if String.lowercase_ascii n = name_lower then Some v else None
-  ) attrs
-
 type label_for_info = {
   for_target : string;
   has_role : bool;
···
     state.in_label <- true;
     state.label_depth <- 1;  (* Start at 1 for the label element itself *)
     state.labelable_count <- 0;
-    let for_value = get_attr element.raw_attrs "for" in
-    let has_role = get_attr element.raw_attrs "role" <> None in
-    let has_aria_label = get_attr element.raw_attrs "aria-label" <> None in
+    let for_value = Attr_utils.get_attr "for" element.raw_attrs in
+    let has_role = Attr_utils.get_attr "role" element.raw_attrs <> None in
+    let has_aria_label = Attr_utils.get_attr "aria-label" element.raw_attrs <> None in
     state.label_for_value <- for_value;
     state.label_has_role <- has_role;
     state.label_has_aria_label <- has_aria_label;
···
 
     (* Track labelable element IDs *)
     (if List.mem name_lower labelable_elements then
-      match get_attr element.raw_attrs "id" with
+      match Attr_utils.get_attr "id" element.raw_attrs with
       | Some id -> state.labelable_ids <- id :: state.labelable_ids
       | None -> ());
 
···
         (* Check if label has for attribute and descendant has mismatched id *)
         (match state.label_for_value with
         | Some for_value ->
-          let descendant_id = get_attr element.raw_attrs "id" in
+          let descendant_id = Attr_utils.get_attr "id" element.raw_attrs in
           (match descendant_id with
            | None ->
              Message_collector.add_typed collector (`Label `For_id_mismatch)
···
     | _ -> ()
   end
 
-let characters _state _text _collector = ()
-
 let end_document state collector =
   List.iter (fun label_info ->
     if List.mem label_info.for_target state.labelable_ids then begin
···
     end
   ) state.labels_for
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~end_document ()

lib/htmlrw_check/specialized/language_checker.ml

···
     Validates language attributes. *)
 
 (** Checker state - currently minimal since we only check attributes. *)
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 
···
   let name = Tag.tag_to_string element.Element.tag in
   process_language_attrs ~element:name ~namespace:None ~attrs:element.raw_attrs ~location collector
 
-let end_element _state ~tag:_ _collector =
-  ()
-
-let characters _state _text _collector =
-  ()
-
-let end_document _state _collector =
-  (* Note: The "missing lang on html" warning is only produced for specific
-     test cases in the Nu validator. We don't produce it by default. *)
-  ()
-
-let checker = (module struct
-  type nonrec state = state
+let end_element _state ~tag:_ _collector = ()
 
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/language_checker.mli

···
     - Empty lang="" is valid (indicates unknown language)
     - Primary language subtag should be valid *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating language attributes. *)

lib/htmlrw_check/specialized/microdata_checker.ml

···
       state.scope_stack <- rest
   | _ -> ()
 
-let characters _state _text _collector =
-  ()
-
 let end_document state collector =
   (* Check all itemref references point to existing IDs *)
   List.iter (fun ref ->
···
   (* Detect itemref cycles *)
   detect_itemref_cycles state collector
 
-let checker = (module struct
-  type nonrec state = state
-
-  let create = create
-  let reset = reset
-  let start_element = start_element
-  let end_element = end_element
-  let characters = characters
-  let end_document = end_document
-end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~end_document ()

lib/htmlrw_check/specialized/microdata_checker.mli

···
     - Detects itemref cycles (A references B, B references A)
     - itemprop values must be valid property names (no colons unless URL) *)
 
-include Checker.S
-
 val checker : Checker.t
 (** [checker] is a checker instance for validating microdata. *)

lib/htmlrw_check/specialized/mime_type_checker.ml

···
   ("object", ["type"]);
 ]
 
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 let reset _state = ()
···
   | _ -> ()  (* Non-HTML elements don't have MIME type checks *)
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/normalization_checker.ml

···
 
     Validates that text content is in Unicode Normalization Form C (NFC). *)
 
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 let reset _state = ()
···
       (`I18n (`Not_nfc (`Replacement replacement)))
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/picture_checker.ml

···
         (`Element (`Text_not_allowed (`Parent "picture")))
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/ruby_checker.ml

···
     | [] -> ()
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/source_checker.ml

···
     let ctx = current_context state in
     (match ctx with
      | Video | Audio ->
-       if Attr_utils.has_attr "srcset" element.raw_attrs then
-         Message_collector.add_typed collector
-           (`Attr (`Not_allowed (`Attr "srcset", `Elem "source")));
-       if Attr_utils.has_attr "sizes" element.raw_attrs then
-         Message_collector.add_typed collector
-           (`Attr (`Not_allowed (`Attr "sizes", `Elem "source")));
-       if Attr_utils.has_attr "width" element.raw_attrs then
-         Message_collector.add_typed collector
-           (`Attr (`Not_allowed (`Attr "width", `Elem "source")));
-       if Attr_utils.has_attr "height" element.raw_attrs then
-         Message_collector.add_typed collector
-           (`Attr (`Not_allowed (`Attr "height", `Elem "source")))
+       (* These attributes are only valid on source in picture, not audio/video *)
+       Attr_utils.check_disallowed_attrs
+         ~element:"source" ~collector ~attrs:element.raw_attrs
+         ["srcset"; "sizes"; "width"; "height"]
      | Picture | Other -> ())
   | _ -> ()
 
···
      | [] -> ())
   | _ -> ()
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/srcset_sizes_checker.ml

···
   "cm"; "mm"; "q"; "in"; "pc"; "pt"; "px"
 ]
 
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 let reset _state = ()
···
   | _ -> ()  (* Other elements *)
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/svg_checker.ml

···
       state.in_svg <- false
   end
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/table_checker.ml

···
           | _ -> ()))
   | _ -> ()  (* Non-HTML elements *)
 
-let characters _state _text _collector = ()
-
 let end_document state collector =
   if !(state.tables) <> [] then
     Message_collector.add_typed collector
       (`Generic "Unclosed table element at end of document.")
 
-let checker =
-  (module struct
-    type nonrec state = state
-
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~end_document ()

lib/htmlrw_check/specialized/table_checker.mli

···
     @see <https://html.spec.whatwg.org/multipage/tables.html> WHATWG HTML: Tables
     @see <https://www.w3.org/TR/html52/tabular-data.html> W3C HTML 5.2: Tables *)
 
-include Checker.S
-
 val checker : Checker.t
 (** A first-class module instance of this checker.
 

lib/htmlrw_check/specialized/title_checker.ml

···
       state.title_has_content <- true
   end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()

lib/htmlrw_check/specialized/unknown_element_checker.ml

···
     | [] -> ())  (* Stack underflow - shouldn't happen *)
   | _ -> ()  (* SVG, MathML, Custom elements *)
 
-let characters _state _text _collector = ()
-
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/url_checker.ml

···
   end
 
 (** Checker state. *)
-type state = unit
+type state = unit [@@warning "-34"]
 
 let create () = ()
 let reset _state = ()
···
   | _ -> ()  (* Non-HTML elements *)
 
 let end_element _state ~tag:_ _collector = ()
-let characters _state _text _collector = ()
-let end_document _state _collector = ()
 
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element ()

lib/htmlrw_check/specialized/xhtml_content_checker.ml

···
             (`Element (`Text_not_allowed (`Parent parent_lower)))
       end
 
-let end_document _state _collector = ()
-
-let checker =
-  (module struct
-    type nonrec state = state
-    let create = create
-    let reset = reset
-    let start_element = start_element
-    let end_element = end_element
-    let characters = characters
-    let end_document = end_document
-  end : Checker.S)
+let checker = Checker.make ~create ~reset ~start_element ~end_element
+    ~characters ()