Turn on -preview=markdown

etc/c/curl.d

@@ -867,7 +867,7 @@ enum CurlOption {
   /** We want the referrer field set automatically when following locations */
   autoreferer = 58,
   /** Port of the proxy, can be set in the proxy string as well with:
-     "[host]:[port]" */
+     `[host]:[port]` */
   proxyport,
   /** size of the POST input data, if strlen() is not good to use */
   postfieldsize,

posix.mak

@@ -490,7 +490,7 @@ $(JSON) : $(ALL_D_FILES)
 ###########################################################
 SRC_DOCUMENTABLES = index.d $(addsuffix .d,$(STD_MODULES) $(EXTRA_DOCUMENTABLES))
 # Set DDOC, the documentation generator
-DDOC=$(DMD) -conf= $(MODEL_FLAG) -w -c -o- -version=StdDdoc \
+DDOC=$(DMD) -conf= $(MODEL_FLAG) -w -c -o- -preview=markdown -version=StdDdoc \
 	-I$(DRUNTIME_PATH)/import $(DMDEXTRAFLAGS)
 
 # D file to html, e.g. std/conv.d -> std_conv.html

std/algorithm/comparison.d

@@ -1751,8 +1751,8 @@ expression.
 
 `choices` needs to be composed of pairs of test expressions and return
 expressions. Each test-expression is compared with `switchExpression` using
-`pred`(`switchExpression` is the first argument) and if that yields true
-- the return expression is returned.
+`pred`(`switchExpression` is the first argument) and if that yields true -
+the return expression is returned.
 
 Both the test and the return expressions are lazily evaluated.
 

std/experimental/allocator/building_blocks/package.d

@@ -235,8 +235,8 @@ $(TR $(TDC2 BitmappedBlock, bitmapped_block) $(TD Organizes one contiguous chunk
 equal-size blocks and tracks allocation status at the cost of one bit per
 block.))
 
-$(TR $(TDC2 FallbackAllocator, fallback_allocator) $(TD Allocator that combines two other allocators
- - primary and fallback. Allocation requests are first tried with primary, and
+$(TR $(TDC2 FallbackAllocator, fallback_allocator) $(TD Allocator that combines two other
+ allocators - primary and fallback. Allocation requests are first tried with primary, and
  upon failure are passed to the fallback. Useful for small and fast allocators
  fronting general-purpose ones.))
 

std/experimental/checkedint.d

@@ -1984,8 +1984,8 @@ static:
     left-hand side operand. If $(D lhs == WithNaN.defaultValue!Lhs), returns
     $(D WithNaN.defaultValue!(typeof(lhs + rhs))) without evaluating the
     operand. Otherwise, evaluates the operand. If evaluation does not overflow,
-    returns the result. Otherwise, returns $(D WithNaN.defaultValue!(typeof(lhs
-    + rhs))).
+    returns the result. Otherwise, returns $(D WithNaN.defaultValue!(typeof(lhs +
+    rhs))).
 
     Params:
     x = The operator symbol
@@ -2023,8 +2023,8 @@ static:
     right-hand side operand. If $(D rhs == WithNaN.defaultValue!Rhs), returns
     $(D WithNaN.defaultValue!(typeof(lhs + rhs))) without evaluating the
     operand. Otherwise, evaluates the operand. If evaluation does not overflow,
-    returns the result. Otherwise, returns $(D WithNaN.defaultValue!(typeof(lhs
-    + rhs))).
+    returns the result. Otherwise, returns $(D WithNaN.defaultValue!(typeof(lhs +
+    rhs))).
 
     Params:
     x = The operator symbol

std/functional.d

@@ -1003,7 +1003,7 @@ if (F.length > 1)
    Params:
         fun = the call-able(s) or `string`(s) to compose into one function
     Returns:
-        A new function `f(x)` that in turn returns $(D fun[0](fun[1](...(x)))...).
+        A new function `f(x)` that in turn returns `fun[0](fun[1](...(x)))...`.
 
    See_Also: $(LREF pipe)
 */
@@ -1054,7 +1054,7 @@ template compose(fun...)
    Params:
         fun = the call-able(s) or `string`(s) to compose into one function
     Returns:
-        A new function `f(x)` that in turn returns $(D fun[0](fun[1](...(x)))...).
+        A new function `f(x)` that in turn returns `fun[0](fun[1](...(x)))...`.
 
    Example:
 

std/math.d

@@ -8461,11 +8461,11 @@ public:
 
 
 /***********************************
- * Evaluate polynomial A(x) = $(SUB a, 0) + $(SUB a, 1)x + $(SUB a, 2)$(POWER x,2)
- *                          + $(SUB a,3)$(POWER x,3); ...
+ * Evaluate polynomial A(x) = $(SUB a, 0) + $(SUB a, 1)x + $(SUB a, 2)$(POWER x,2) +
+ *                          $(SUB a,3)$(POWER x,3); ...
  *
- * Uses Horner's rule A(x) = $(SUB a, 0) + x($(SUB a, 1) + x($(SUB a, 2)
- *                         + x($(SUB a, 3) + ...)))
+ * Uses Horner's rule A(x) = $(SUB a, 0) + x($(SUB a, 1) + x($(SUB a, 2) +
+ *                         x($(SUB a, 3) + ...)))
  * Params:
  *      x =     the value to evaluate.
  *      A =     array of coefficients $(SUB a, 0), $(SUB a, 1), etc.

std/parallelism.d

@@ -3007,9 +3007,9 @@ public:
     The main uses cases for `WorkerLocalStorageStorage` are:
 
     1.  Performing parallel reductions with an imperative, as opposed to
-    functional, programming style.  In this case, it's useful to treat
-    `WorkerLocalStorageStorage` as local to each thread for only the parallel
-    portion of an algorithm.
+        functional, programming style.  In this case, it's useful to treat
+        `WorkerLocalStorageStorage` as local to each thread for only the parallel
+        portion of an algorithm.
 
     2.  Recycling temporary buffers across iterations of a parallel foreach loop.
 

std/path.d

@@ -3586,7 +3586,7 @@ if (isConvertibleToString!Range)
         $(LI `filename` must not contain any characters whose integer
             representation is in the range 0-31.)
         $(LI `filename` must not contain any of the following $(I reserved
-            characters): <>:"/\|?*)
+            characters): `<>:"/\|?*`)
         $(LI `filename` may not end with a space ($(D ' ')) or a period
             (`'.'`).)
     )

std/range/package.d

@@ -5813,8 +5813,8 @@ $(D (n - State.length)).
 
 If the function is passed in string form, the state has name `"a"`
 and the zero-based index in the recurrence has name `"n"`. The
-given string must return the desired value for `a[n]` given $(D a[n
-- 1]), $(D a[n - 2]), $(D a[n - 3]),..., $(D a[n - stateSize]). The
+given string must return the desired value for `a[n]` given
+`a[n - 1]`, `a[n - 2]`, `a[n - 3]`,..., `a[n - stateSize]`. The
 state size is dictated by the number of arguments passed to the call
 to `recurrence`. The `Recurrence` struct itself takes care of
 managing the recurrence's state and shifting it appropriately.

std/regex/package.d

@@ -136,7 +136,7 @@ $(TR $(TD Objects) $(TD
     $(REG_ROW \W, Matches any non-word character.)
     $(REG_ROW \s, Matches whitespace, same as \p{White_Space}.)
     $(REG_ROW \S, Matches any character except those recognized as $(I \s ). )
-    $(REG_ROW \\, Matches \ character. )
+    $(REG_ROW \\\\, Matches \ character. )
     $(REG_ROW \c where c is one of [|*+?(), Matches the character c itself. )
     $(REG_ROW \p{PropertyName}, Matches a character that belongs
         to the Unicode PropertyName set.
@@ -261,7 +261,7 @@ $(TR $(TD Objects) $(TD
         $(REG_ROW $', part of input $(I following) the match. )
         $(REG_ROW $$, '$' character. )
         $(REG_ROW \c $(COMMA) where c is any character, the character c itself. )
-        $(REG_ROW \\, '\' character. )
+        $(REG_ROW \\\\, '\\' character. )
         $(REG_ROW $(DOLLAR)1 .. $(DOLLAR)99, submatch number 1 to 99 respectively. )
     )
 

std/typecons.d

@@ -8714,8 +8714,8 @@ public:
 // ReplaceType
 /**
 Replaces all occurrences of `From` into `To`, in one or more types `T`. For
-example, $(D ReplaceType!(int, uint, Tuple!(int, float)[string])) yields
-$(D Tuple!(uint, float)[string]). The types in which replacement is performed
+example, `ReplaceType!(int, uint, Tuple!(int, float)[string])` yields
+`Tuple!(uint, float)[string]`. The types in which replacement is performed
 may be arbitrarily complex, including qualifiers, built-in type constructors
 (pointers, arrays, associative arrays, functions, and delegates), and template
 instantiations; replacement proceeds transitively through the type definition.

std/uni.d

@@ -2027,8 +2027,8 @@ pure:
     ---
     $(P
     The way to read this is: start with negative meaning that all numbers
-    smaller then the next one are not present in this set (and positive
-    - the contrary). Then switch positive/negative after each
+    smaller then the next one are not present in this set (and positive -
+    the contrary). Then switch positive/negative after each
     number passed from left to right.
     )
     $(P This way negative spans until 10, then positive until 50,