use Math_block and Math_span instead of one Math constr + boolean

Author: giltho

src/ast.ml

@@ -23,7 +23,7 @@ type inline_element =
   | `Reference of
     reference_kind * string with_location * inline_element with_location list
   | `Link of string * inline_element with_location list
-  | `Math of bool * string ]
+  | `Math_span of string ]
 (** Inline elements are equivalent to what would be found in a [span] in HTML.
     Mostly these are straightforward. The [`Reference] constructor takes a triple
     whose second element is the reference itself, and the third the replacement
@@ -41,7 +41,8 @@ type nestable_block_element =
   | `List of
     [ `Unordered | `Ordered ]
     * [ `Light | `Heavy ]
-    * nestable_block_element with_location list list ]
+    * nestable_block_element with_location list list
+  | `Math_block of string ]
 (** Some block elements may be nested within lists or tags, but not all.
     The [`List] constructor has a parameter of type [\[`Light | `Heavy\]].
     This corresponds to the syntactic constructor used (see the

src/lexer.mll

@@ -27,7 +27,7 @@ let unescape_word : string -> string = fun s ->
     scan_word 0;
     Buffer.contents buffer
 
-
+let math_constr inline x = if inline then `Math_span x else `Math_block x
 
 (* This is used for code and verbatim blocks. It can be done with a regular
    expression, but the regexp gets quite ugly, so a function is easier to
@@ -549,7 +549,7 @@ and code_span buffer nesting_level start_offset input = parse
 and math inline buffer nesting_level start_offset input = parse
   | '}'
     { if nesting_level == 0 then
-        emit input (`Math (inline, Buffer.contents buffer)) ~start_offset
+        emit input (math_constr inline (Buffer.contents buffer)) ~start_offset
       else begin
         Buffer.add_char buffer '}';
         math inline buffer (nesting_level - 1) start_offset input lexbuf
@@ -569,7 +569,7 @@ and math inline buffer nesting_level start_offset input = parse
             input
             (Parse_error.not_allowed
               ~what:(Token.describe (`Blank_line "\n"))
-              ~in_what:(Token.describe (`Math (inline, ""))));
+              ~in_what:(Token.describe (math_constr inline "")));
           Buffer.add_char buffer '\n';
           math inline buffer nesting_level start_offset input lexbuf
         end
@@ -584,8 +584,8 @@ and math inline buffer nesting_level start_offset input = parse
         input
         (Parse_error.not_allowed
           ~what:(Token.describe `End)
-          ~in_what:(Token.describe (`Math (inline, ""))));
-      emit input (`Math (inline, Buffer.contents buffer)) ~start_offset }
+          ~in_what:(Token.describe (math_constr inline "")));
+      emit input (math_constr inline (Buffer.contents buffer)) ~start_offset }
   | _ as c
     { Buffer.add_char buffer c;
       math inline buffer nesting_level start_offset input lexbuf }

src/syntax.ml

@@ -55,7 +55,7 @@ type token_that_always_begins_an_inline_element =
   | `Begin_reference_with_replacement_text of string
   | `Simple_link of string
   | `Begin_link_with_replacement_text of string
-  | `Math of bool * string ]
+  | `Math_span of string ]
 
 (* Check that the token constructors above actually are all in [Token.t]. *)
 let _check_subset : token_that_always_begins_an_inline_element -> Token.t =
@@ -100,15 +100,9 @@ let rec inline_element :
   | `Plus ->
       junk input;
       Loc.at location (`Word "+")
-  | `Code_span c ->
+  | (`Code_span _ | `Math_span _ | `Raw_markup _) as token ->
       junk input;
-      Loc.at location (`Code_span c)
-  | `Raw_markup (raw_markup_target, s) ->
-      junk input;
-      Loc.at location (`Raw_markup (raw_markup_target, s))
-  | `Math _ as tk ->
-      junk input;
-      Loc.at location tk
+      Loc.at location token
   | `Begin_style s as parent_markup ->
       junk input;
 
@@ -734,10 +728,11 @@ let rec block_element_list :
         let block = Loc.at location block in
         let acc = block :: acc in
         consume_block_elements ~parsed_a_tag `After_text acc
-    | { value = `Code_block (_, s) as token; location } as next_token ->
+    | ( { value = `Code_block (_, { value = s; _ }) as token; location }
+      | { value = `Math_block s as token; location } ) as next_token ->
         warn_if_after_tags next_token;
         warn_if_after_text next_token;
-        if s.value = "" then
+        if s = "" then
           Parse_error.should_not_be_empty ~what:(Token.describe token) location
           |> add_warning input;
 

src/token.ml

@@ -53,8 +53,8 @@ type t =
     string
   | `Code_span of string
   | `Raw_markup of string option * string
-  | `Math of bool * string
-    (* The boolean is true iff the math is a inline *)
+  | `Math_span of string
+  | `Math_block of string
   | `Begin_style of style
   | `Begin_paragraph_style of paragraph_style
   | (* Other inline element markup. *)
@@ -125,7 +125,8 @@ let describe : [< t | `Comment ] -> string = function
   | `Begin_style `Emphasis -> "'{e ...}' (emphasized text)"
   | `Begin_style `Superscript -> "'{^...}' (superscript)"
   | `Begin_style `Subscript -> "'{_...}' (subscript)"
-  | `Math (b, _) -> if b then "'{m ...}' (inline math)" else "'{math ...}' (math block)"
+  | `Math_span _ -> "'{m ...}' (math span)"
+  | `Math_block _ -> "'{math ...}' (math block)"
   | `Simple_reference _ -> "'{!...}' (cross-reference)"
   | `Begin_reference_with_replacement_text _ ->
       "'{{!...} ...}' (cross-reference)"

test/test.ml

@@ -41,9 +41,7 @@ module Ast_to_sexp = struct
     | `Code_span c -> List [ Atom "code_span"; Atom c ]
     | `Raw_markup (target, s) ->
         List [ Atom "raw_markup"; opt str target; Atom s ]
-    | `Math (b, s) ->
-      let b_descr = if b then Atom "inline" else Atom "block" in 
-      List [Atom "math"; b_descr; Atom s]
+    | `Math_span s -> List [ Atom "math_span"; Atom s ]
     | `Styled (s, es) ->
         List [ style s; List (List.map (at.at (inline_element at)) es) ]
     | `Reference (kind, r, es) ->
@@ -64,6 +62,7 @@ module Ast_to_sexp = struct
     | `Paragraph es ->
         List
           [ Atom "paragraph"; List (List.map (at.at (inline_element at)) es) ]
+    | `Math_block s -> List [ Atom "math_block"; Atom s ]
     | `Code_block (None, c) -> List [ Atom "code_block"; at.at str c ]
     | `Code_block (Some meta, c) ->
         List [ Atom "code_block"; code_block_meta at meta; at.at str c ]
@@ -5311,14 +5310,14 @@ let%expect_test _ =
   let module Math = struct
     let block =
       test "{math \\sum_{i=0}^n x^i%}";
-      [%expect {|
-        ((output
-          (((f.ml (1 0) (1 24))
-            (paragraph (((f.ml (1 0) (1 24)) (math block "\\sum_{i=0}^n x^i%")))))))
+      [%expect
+        {|
+        ((output (((f.ml (1 0) (1 24)) (math_block "\\sum_{i=0}^n x^i%"))))
          (warnings ())) |}]
-      
+
     let complex_block =
-      test {|{math
+      test
+        {|{math
       \alpha(x)=\left\{
                 \begin{array}{ll}                 % beginning of the array
                   x \% 4\\                        % some variable modulo 4
@@ -5327,54 +5326,55 @@ let%expect_test _ =
                 \end{array}                       % end of the array
               \right.
       }|};
-      [%expect {|
+      [%expect
+        {|
         ((output
           (((f.ml (1 0) (9 7))
-            (paragraph
-             (((f.ml (1 0) (9 7))
-               (math block
-                 "      \\alpha(x)=\\left\\{\
-                \n                \\begin{array}{ll}                 % beginning of the array\
-                \n                  x \\% 4\\\\                        % some variable modulo 4\
-                \n                  \\frac{1}{1+e^{-kx}}\\\\           % something else\
-                \n                  \\frac{e^x-e^{-x}}{e^x+e^{-x}}   % another action\
-                \n                \\end{array}                       % end of the array\
-                \n              \\right.\
-                \n      ")))))))
-         (warnings ())) |}]
-    
+            (math_block
+              "      \\alpha(x)=\\left\\{\
+             \n                \\begin{array}{ll}                 % beginning of the array\
+             \n                  x \\% 4\\\\                        % some variable modulo 4\
+             \n                  \\frac{1}{1+e^{-kx}}\\\\           % something else\
+             \n                  \\frac{e^x-e^{-x}}{e^x+e^{-x}}   % another action\
+             \n                \\end{array}                       % end of the array\
+             \n              \\right.\
+             \n      "))))
+         (warnings ())) |}]
+
     let inline =
       test "{m x + 4}";
-      [%expect {|
+      [%expect
+        {|
         ((output
           (((f.ml (1 0) (1 9))
-            (paragraph (((f.ml (1 0) (1 9)) (math inline "x + 4")))))))
+            (paragraph (((f.ml (1 0) (1 9)) (math_span "x + 4")))))))
          (warnings ())) |}]
-    
+
     let inline_nested =
       test "{m \\sub_{i=0}^n x^i}";
-      [%expect {|
+      [%expect
+        {|
         ((output
           (((f.ml (1 0) (1 20))
-            (paragraph (((f.ml (1 0) (1 20)) (math inline "\\sub_{i=0}^n x^i")))))))
+            (paragraph (((f.ml (1 0) (1 20)) (math_span "\\sub_{i=0}^n x^i")))))))
          (warnings ())) |}]
-    
+
     let inline_false_nesting =
       test "{m \\{ \\mathbb{only_left}}";
-      [%expect {|
+      [%expect
+        {|
         ((output
           (((f.ml (1 0) (1 25))
-            (paragraph
-             (((f.ml (1 0) (1 25)) (math inline "\\{ \\mathbb{only_left}")))))))
+            (paragraph (((f.ml (1 0) (1 25)) (math_span "\\{ \\mathbb{only_left}")))))))
          (warnings ())) |}]
-    
+
     let inline_false_terminator =
-    test "{m \\mathbb{only_left}\\}}";
-    [%expect {|
+      test "{m \\mathbb{only_left}\\}}";
+      [%expect
+        {|
       ((output
         (((f.ml (1 0) (1 24))
-          (paragraph
-           (((f.ml (1 0) (1 24)) (math inline "\\mathbb{only_left}\\}")))))))
+          (paragraph (((f.ml (1 0) (1 24)) (math_span "\\mathbb{only_left}\\}")))))))
        (warnings ())) |}]
   end in
-  ()
+  ()