From 764caefa36c88eefaa2864607d925e3d38f673cd Mon Sep 17 00:00:00 2001
From: anonymous <aG0aep6G@users.noreply.github.com>
Date: Wed, 25 May 2016 21:25:04 +0200
Subject: [PATCH] XREF -> REF (sed)

Done by:

(find . -type f -name "*.d" -print0; \
    find . -type f -name "*.dd" -print0) | \
xargs -0 sed -i -r \
    's/\$\(XREF\s+([^(),]*),\s*([^(),]*)\)/$(REF \2, std,\1)/g'
---
 changelog.dd               | 18 ++++++++--------
 std/algorithm/comparison.d |  2 +-
 std/algorithm/iteration.d  | 40 +++++++++++++++++-----------------
 std/algorithm/mutation.d   |  4 ++--
 std/algorithm/searching.d  |  6 +++---
 std/algorithm/setops.d     |  2 +-
 std/algorithm/sorting.d    | 18 ++++++++--------
 std/array.d                |  6 +++---
 std/bigint.d               |  2 +-
 std/complex.d              |  6 +++---
 std/concurrency.d          | 10 ++++-----
 std/container/rbtree.d     |  2 +-
 std/conv.d                 |  4 ++--
 std/digest/digest.d        |  2 +-
 std/digest/hmac.d          |  4 ++--
 std/encoding.d             |  2 +-
 std/exception.d            |  2 +-
 std/file.d                 |  8 +++----
 std/format.d               |  4 ++--
 std/functional.d           |  2 +-
 std/json.d                 |  4 ++--
 std/net/curl.d             |  8 +++----
 std/numeric.d              |  2 +-
 std/outbuffer.d            | 12 +++++------
 std/parallelism.d          | 14 ++++++------
 std/path.d                 |  6 +++---
 std/process.d              | 34 ++++++++++++++---------------
 std/range/package.d        | 10 ++++-----
 std/stdio.d                | 16 +++++++-------
 std/string.d               | 44 +++++++++++++++++++-------------------
 std/traits.d               |  2 +-
 std/typecons.d             |  4 ++--
 std/typetuple.d            |  2 +-
 std/uni.d                  | 22 +++++++++----------
 std/utf.d                  |  2 +-
 std/uuid.d                 |  6 +++---
 std/zip.d                  |  2 +-
 37 files changed, 167 insertions(+), 167 deletions(-)

diff --git a/changelog.dd b/changelog.dd
index 1a63ee3ebaf..a6dc6a11721 100644
--- a/changelog.dd
+++ b/changelog.dd
@@ -28,12 +28,12 @@ $(BUGSTITLE Library Changes,
         exposed))
     $(LI $(RELATIVE_LINK2 iota-length-size_t, `std.range.iota's `.length`
         property is fixed to `size_t` instead of the type being iterated))
-    $(LI $(XREF uni, isNumber) and $(XREF uni, isPunctuation) now use a separate,
+    $(LI $(REF isNumber, std,uni) and $(REF isPunctuation, std,uni) now use a separate,
     optimized path for ASCII inputs.)
-    $(LI $(XREF uni, isAlphaNum), which is analogous to $(XREF ascii, isAlphaNum)
+    $(LI $(REF isAlphaNum, std,uni), which is analogous to $(REF isAlphaNum, std,ascii)
         was added.)
-    $(LI $(XREF regex, regex) now supports inline comments with (?#...) syntax.)
-    $(LI std.regex had numerous optimization applied, compile-time $(XREF regex, ctRegex)
+    $(LI $(REF regex, std,regex) now supports inline comments with (?#...) syntax.)
+    $(LI std.regex had numerous optimization applied, compile-time $(REF ctRegex, std,regex)
     should now be generally faster then the run-time version.)
     $(LI $(REF moveAt, std,range,primitives) accepts only `size_t` for its index
     arguments.)
@@ -42,7 +42,7 @@ $(BUGSTITLE Library Changes,
     $(LI $(REF readLink, std,file) and $(REF symlink, std,file) have been
         rangified.)
     $(LI All overloads of `std.conv.toImpl` has been made private. Please use
-        $(XREF conv, to) instead.)
+        $(REF to, std,conv) instead.)
     $(LI $(RELATIVE_LINK2 min-max-element,
     `std.algorithm.searching.{min,max}Element` for ranges have been added.))
     $(LI $(XREF Ternary, std,typecons) was added to represent three valued
@@ -63,7 +63,7 @@ $(LI $(LNAME2 process, Process creation in `std.process` was sped up on Posix.)
 $(LI $(LNAME2 std-algorithm-iteration-cumulativeFold, $(XREF algorithm.iteration,
 cumulativeFold) was added.)
 
-    $(P $(XREF algorithm.iterator, cumulativeFold) returns the successive
+    $(P $(REF cumulativeFold, std,algorithm.iterator) returns the successive
         reduced values of an input range.)
 ------
 assert([1, 2, 3, 4, 5].cumulativeFold!((a, b) => a + b).array == [1, 3, 6, 10, 15]);
@@ -73,7 +73,7 @@ assert([1, 2, 3].cumulativeFold!((a, b) => a + b)(100).array == [101, 103, 106])
 
 $(LI $(LNAME2 padLeft-padRight, `std.range.padLeft` and `std.range.padRight`
         were added.)
-    $(P $(XREF range, padLeft) and $(XREF range, padRight) are functions for
+    $(P $(REF padLeft, std,range) and $(REF padRight, std,range) are functions for
         padding ranges to a specified length using the given element.
     )
 
@@ -102,7 +102,7 @@ assert(m.front[1] == "12");
 -------
 )
 
-$(LI $(LNAME2 regex-with-matches, $(XREF regex, splitter) now supports keeping the
+$(LI $(LNAME2 regex-with-matches, $(REF splitter, std,regex) now supports keeping the
 pattern matches in the resulting range.)
 -------
 import std.regex;
@@ -203,7 +203,7 @@ $(LI $(LNAME2 mutation, `std.algorithm.mutation.swapAt` was exposed)
 
 $(LI $(LNAME2 iota-length-size_t, `std.range.iota's `.length` property is fixed
         to `size_t` instead of the type being iterated)
-    $(P $(XREF range, iota)'s `.length` property is now always returned as
+    $(P $(REF iota, std,range)'s `.length` property is now always returned as
         `size_t`.  This means if you are on a 32-bit CPU and you are using
         iota to iterate 64-bit types, the length will be truncated to `size_t`.
         In non-release mode, you will get an exception if the length exceeds
diff --git a/std/algorithm/comparison.d b/std/algorithm/comparison.d
index e049ee47d0e..3e6e2db7637 100644
--- a/std/algorithm/comparison.d
+++ b/std/algorithm/comparison.d
@@ -1767,7 +1767,7 @@ the benefit of have better complexity than the $(D AllocateGC.no) option. Howeve
 this option is only available for ranges whose equality can be determined via each
 element's $(D toHash) method. If customized equality is needed, then the $(D pred)
 template parameter can be passed, and the function will automatically switch to
-the non-allocating algorithm. See $(XREF functional,binaryFun) for more details on
+the non-allocating algorithm. See $(REF binaryFun, std,functional) for more details on
 how to define $(D pred).
 
 Non-allocating forward range option: $(BIGOH n^2)
diff --git a/std/algorithm/iteration.d b/std/algorithm/iteration.d
index a7804411292..2a08eb79cf5 100644
--- a/std/algorithm/iteration.d
+++ b/std/algorithm/iteration.d
@@ -122,7 +122,7 @@ The result is then directly returned when $(D front) is called,
 rather than re-evaluated.
 
 This can be a useful function to place in a chain, after functions
-that have expensive evaluation, as a lazy alternative to $(XREF array,array).
+that have expensive evaluation, as a lazy alternative to $(REF array, std,array).
 In particular, it can be placed after a call to $(D map), or before a call
 to $(D filter).
 
@@ -205,7 +205,7 @@ Tip: $(D cache) is eager when evaluating elements. If calling front on the
 underlying _range has a side effect, it will be observeable before calling
 front on the actual cached _range.
 
-Furthermore, care should be taken composing $(D cache) with $(XREF _range,take).
+Furthermore, care should be taken composing $(D cache) with $(REF take, std,_range).
 By placing $(D take) before $(D cache), then $(D cache) will be "aware"
 of when the _range ends, and correctly stop caching elements when needed.
 If calling front has no side effect though, placing $(D take) after $(D cache)
@@ -840,13 +840,13 @@ can be avoided by explicitly specifying a predicate lambda with a
 $(D lazy) parameter.
 
 $(D each) also supports $(D opApply)-based iterators, so it will work
-with e.g. $(XREF parallelism, parallel).
+with e.g. $(REF parallel, std,parallelism).
 
 Params:
     pred = predicate to apply to each element of the range
     r = range or iterable over which each iterates
 
-See_Also: $(XREF range,tee)
+See_Also: $(REF tee, std,range)
 
  */
 template each(alias pred = "a")
@@ -1029,7 +1029,7 @@ unittest
 $(D auto filter(Range)(Range rs) if (isInputRange!(Unqual!Range));)
 
 Implements the higher order _filter function. The predicate is passed to
-$(XREF functional,unaryFun), and can either accept a string, or any callable
+$(REF unaryFun, std,functional), and can either accept a string, or any callable
 that can be executed via $(D pred(element)).
 
 Params:
@@ -1232,9 +1232,9 @@ private struct FilterResult(alias pred, Range)
  * finding the last element in the range that satisfies the filtering
  * condition (in addition to finding the first one). The advantage is
  * that the filtered range can be spanned from both directions. Also,
- * $(XREF range, retro) can be applied against the filtered range.
+ * $(REF retro, std,range) can be applied against the filtered range.
  *
- * The predicate is passed to $(XREF functional,unaryFun), and can either
+ * The predicate is passed to $(REF unaryFun, std,functional), and can either
  * accept a string, or any callable that can be executed via $(D pred(element)).
  *
  * Params:
@@ -1325,7 +1325,7 @@ Similarly to $(D uniq), $(D group) produces a range that iterates over unique
 consecutive elements of the given range. Each element of this range is a tuple
 of the element and the number of times it is repeated in the original range.
 Equivalence of elements is assessed by using the predicate $(D pred), which
-defaults to $(D "a == b").  The predicate is passed to $(XREF functional,binaryFun),
+defaults to $(D "a == b").  The predicate is passed to $(REF binaryFun, std,functional),
 and can either accept a string, or any callable that can be executed via
 $(D pred(element, element)).
 
@@ -1772,8 +1772,8 @@ unittest
  * Chunks an input range into subranges of equivalent adjacent elements.
  *
  * Equivalence is defined by the predicate $(D pred), which can be either
- * binary, which is passed to $(XREF functional,binaryFun), or unary, which is
- * passed to $(XREF functional,unaryFun). In the binary form, two _range elements
+ * binary, which is passed to $(REF binaryFun, std,functional), or unary, which is
+ * passed to $(REF unaryFun, std,functional). In the binary form, two _range elements
  * $(D a) and $(D b) are considered equivalent if $(D pred(a,b)) is true. In
  * unary form, two elements are considered equivalent if $(D pred(a) == pred(b))
  * is true.
@@ -2025,7 +2025,7 @@ both outer and inner ranges of $(D RoR) are forward ranges; otherwise it will
 be only an input range.
 
 See_also:
-$(XREF range,chain), which chains a sequence of ranges with compatible elements
+$(REF chain, std,range), which chains a sequence of ranges with compatible elements
 into a single range.
  */
 auto joiner(RoR, Separator)(RoR r, Separator sep)
@@ -2626,7 +2626,7 @@ template reduce(fun...) if (fun.length >= 1)
     /++
     Seed version. The seed should be a single value if $(D fun) is a
     single function. If $(D fun) is multiple functions, then $(D seed)
-    should be a $(XREF typecons,Tuple), with one field per function in $(D f).
+    should be a $(REF Tuple, std,typecons), with one field per function in $(D f).
 
     For convenience, if the seed is const, or has qualified fields, then
     $(D reduce) will operate on an unqualified copy. If this happens
@@ -2768,7 +2768,7 @@ Sometimes it is very useful to compute multiple aggregates in one pass.
 One advantage is that the computation is faster because the looping overhead
 is shared. That's why $(D reduce) accepts multiple functions.
 If two or more functions are passed, $(D reduce) returns a
-$(XREF typecons, Tuple) object with one member per passed-in function.
+$(REF Tuple, std,typecons) object with one member per passed-in function.
 The number of seeds must be correspondingly increased.
 */
 @safe unittest
@@ -3459,7 +3459,7 @@ Two adjacent separators are considered to surround an empty element in
 the split range. Use $(D filter!(a => !a.empty)) on the result to compress
 empty elements.
 
-The predicate is passed to $(XREF functional,binaryFun), and can either accept
+The predicate is passed to $(REF binaryFun, std,functional), and can either accept
 a string, or any callable that can be executed via $(D pred(element, s)).
 
 If the empty range is given, the result is a range with one empty
@@ -3488,7 +3488,7 @@ Returns:
     likewise.
 
 See_Also:
- $(XREF regex, _splitter) for a version that splits using a regular
+ $(REF _splitter, std,regex) for a version that splits using a regular
 expression defined separator.
 */
 auto splitter(alias pred = "a == b", Range, Separator)(Range r, Separator s)
@@ -3744,7 +3744,7 @@ if (is(typeof(binaryFun!pred(r.front, s)) : bool)
 Similar to the previous overload of $(D splitter), except this one uses another
 range as a separator. This can be used with any narrow string type or sliceable
 range type, but is most popular with string types. The predicate is passed to
-$(XREF functional,binaryFun), and can either accept a string, or any callable
+$(REF binaryFun, std,functional), and can either accept a string, or any callable
 that can be executed via $(D pred(r.front, s.front)).
 
 Two adjacent separators are considered to surround an empty element in
@@ -3768,7 +3768,7 @@ Returns:
     is a forward range or bidirectional range, the returned range will be
     likewise.
 
-See_Also: $(XREF regex, _splitter) for a version that splits using a regular
+See_Also: $(REF _splitter, std,regex) for a version that splits using a regular
 expression defined separator.
  */
 auto splitter(alias pred = "a == b", Range, Separator)(Range r, Separator s)
@@ -4017,7 +4017,7 @@ if (is(typeof(binaryFun!pred(r.front, s.front)) : bool)
 
 Similar to the previous overload of $(D splitter), except this one does not use a separator.
 Instead, the predicate is an unary function on the input range's element type.
-The $(D isTerminator) predicate is passed to $(XREF functional,unaryFun) and can
+The $(D isTerminator) predicate is passed to $(REF unaryFun, std,functional) and can
 either accept a string, or any callable that can be executed via $(D pred(element, s)).
 
 Two adjacent separators are considered to surround an empty element in
@@ -4037,7 +4037,7 @@ Returns:
     is a forward range or bidirectional range, the returned range will be
     likewise.
 
-See_Also: $(XREF regex, _splitter) for a version that splits using a regular
+See_Also: $(REF _splitter, std,regex) for a version that splits using a regular
 expression defined separator.
  */
 auto splitter(alias isTerminator, Range)(Range input)
@@ -4754,7 +4754,7 @@ Lazily iterates unique consecutive elements of the given range (functionality
 akin to the $(WEB wikipedia.org/wiki/_Uniq, _uniq) system
 utility). Equivalence of elements is assessed by using the predicate
 $(D pred), by default $(D "a == b"). The predicate is passed to
-$(XREF functional,binaryFun), and can either accept a string, or any callable
+$(REF binaryFun, std,functional), and can either accept a string, or any callable
 that can be executed via $(D pred(element, element)). If the given range is
 bidirectional, $(D uniq) also yields a bidirectional range.
 
diff --git a/std/algorithm/mutation.d b/std/algorithm/mutation.d
index 1ca779dd917..3c7a680a94c 100644
--- a/std/algorithm/mutation.d
+++ b/std/algorithm/mutation.d
@@ -385,7 +385,7 @@ range elements, different types of ranges are accepted:
 
 /**
 To _copy at most $(D n) elements from a range, you may want to use
-$(XREF range, take):
+$(REF take, std,range):
 */
 @safe unittest
 {
@@ -412,7 +412,7 @@ use $(LREF filter):
 }
 
 /**
-$(XREF range, retro) can be used to achieve behavior similar to
+$(REF retro, std,range) can be used to achieve behavior similar to
 $(WEB sgi.com/tech/stl/copy_backward.html, STL's copy_backward'):
 */
 @safe unittest
diff --git a/std/algorithm/searching.d b/std/algorithm/searching.d
index c2d8413081e..7a9375e06a8 100644
--- a/std/algorithm/searching.d
+++ b/std/algorithm/searching.d
@@ -33,7 +33,7 @@ $(T2 endsWith,
         $(D endsWith("rocks", "ks")) returns $(D true).)
 $(T2 find,
         $(D find("hello world", "or")) returns $(D "orld") using linear search.
-        (For binary search refer to $(XREF range,sortedRange).))
+        (For binary search refer to $(REF sortedRange, std,range).))
 $(T2 findAdjacent,
         $(D findAdjacent([1, 2, 3, 3, 4])) returns the subrange starting with
         two equal adjacent elements, i.e. $(D [3, 3, 4]).)
@@ -398,7 +398,7 @@ $(D takeExactly(r1, n)), where $(D n) is the number of elements in the common
 prefix of both ranges.
 
 See_Also:
-    $(XREF range, takeExactly)
+    $(REF takeExactly, std,range)
  */
 auto commonPrefix(alias pred = "a == b", R1, R2)(R1 r1, R2 r2)
 if (isForwardRange!R1 && isInputRange!R2 &&
@@ -1317,7 +1317,7 @@ pred). Performs $(BIGOH walkLength(haystack)) evaluations of $(D
 pred).
 
 To _find the last occurrence of $(D needle) in $(D haystack), call $(D
-find(retro(haystack), needle)). See $(XREF range, retro).
+find(retro(haystack), needle)). See $(REF retro, std,range).
 
 Params:
 
diff --git a/std/algorithm/setops.d b/std/algorithm/setops.d
index 3c865fc02bc..fac62c19a5f 100644
--- a/std/algorithm/setops.d
+++ b/std/algorithm/setops.d
@@ -72,7 +72,7 @@ Params:
     otherRanges = Zero or more non-infinite forward ranges
 
 Returns:
-    A forward range of $(XREF typecons,Tuple) representing elements of the
+    A forward range of $(REF Tuple, std,typecons) representing elements of the
     cartesian product of the given ranges.
 */
 auto cartesianProduct(R1, R2)(R1 range1, R2 range2)
diff --git a/std/algorithm/sorting.d b/std/algorithm/sorting.d
index 1aa838eb740..efd37050a38 100644
--- a/std/algorithm/sorting.d
+++ b/std/algorithm/sorting.d
@@ -10,7 +10,7 @@ $(T2 completeSort,
         $(D completeSort(a, b)) leaves $(D a = [6, 10, 15]) and $(D b = [20,
         30, 40]).
         The range $(D a) must be sorted prior to the call, and as a result the
-        combination $(D $(XREF range,chain)(a, b)) is sorted.)
+        combination $(D $(REF chain, std,range)(a, b)) is sorted.)
 $(T2 isPartitioned,
         $(D isPartitioned!"a < 0"([-1, -2, 1, 0, 2])) returns $(D true) because
         the predicate is $(D true) for a portion of the range and $(D false)
@@ -594,7 +594,7 @@ Params:
     pivot = The pivot element.
 
 Returns:
-    A $(XREF typecons,Tuple) of the three resulting ranges. These ranges are
+    A $(REF Tuple, std,typecons) of the three resulting ranges. These ranges are
     slices of the original range.
 
 BUGS: stable $(D partition3) has not been implemented yet.
@@ -1084,12 +1084,12 @@ Sorts a random-access range according to the predicate $(D less). Performs
 $(BIGOH r.length * log(r.length)) evaluations of $(D less). Stable sorting
 requires $(D hasAssignableElements!Range) to be true.
 
-$(D sort) returns a $(XREF range, SortedRange) over the original range, which
+$(D sort) returns a $(REF SortedRange, std,range) over the original range, which
 functions that can take advantage of sorted data can then use to know that the
-range is sorted and adjust accordingly. The $(XREF range, SortedRange) is a
+range is sorted and adjust accordingly. The $(REF SortedRange, std,range) is a
 wrapper around the original range, so both it and the original range are sorted,
 but other functions won't know that the original range has been sorted, whereas
-they $(I can) know that $(XREF range, SortedRange) has been sorted.
+they $(I can) know that $(REF SortedRange, std,range) has been sorted.
 
 The predicate is expected to satisfy certain rules in order for $(D sort) to
 behave as expected - otherwise, the program may fail on certain inputs (but not
@@ -1099,7 +1099,7 @@ $(D less(a,c)) (transitivity), and, conversely, $(D !less(a,b) && !less(b,c)) to
 imply $(D !less(a,c)). Note that the default predicate ($(D "a < b")) does not
 always satisfy these conditions for floating point types, because the expression
 will always be $(D false) when either $(D a) or $(D b) is NaN.
-Use $(XREF math, cmp) instead.
+Use $(REF cmp, std,math) instead.
 
 If `less` involves expensive computations on the _sort key, it may be
 worthwhile to use $(LREF schwartzSort) instead.
@@ -1121,10 +1121,10 @@ or more allocations per call. Both algorithms have $(BIGOH n log n) worst-case
 time complexity.
 
 See_Also:
-    $(XREF range, assumeSorted)$(BR)
-    $(XREF range, SortedRange)$(BR)
+    $(REF assumeSorted, std,range)$(BR)
+    $(REF SortedRange, std,range)$(BR)
     $(XREF_PACK algorithm,mutation,SwapStrategy)$(BR)
-    $(XREF functional, binaryFun)
+    $(REF binaryFun, std,functional)
 */
 SortedRange!(Range, less)
 sort(alias less = "a < b", SwapStrategy ss = SwapStrategy.unstable,
diff --git a/std/array.d b/std/array.d
index bd4e31c99f3..50072c7ed31 100644
--- a/std/array.d
+++ b/std/array.d
@@ -339,7 +339,7 @@ range, which must be a range of tuples (Key, Value). Returns a null associative
 array reference when given an empty range.
 Duplicates: Associative arrays have unique keys. If r contains duplicate keys,
 then the result will contain the value of the last pair for that key in r.
-See_Also: $(XREF typecons, Tuple)
+See_Also: $(REF Tuple, std,typecons)
  */
 
 auto assocArray(Range)(Range r)
@@ -1247,7 +1247,7 @@ pure nothrow bool sameTail(T)(in T[] lhs, in T[] rhs)
 /********************************************
 Returns an array that consists of $(D s) (which must be an input
 range) repeated $(D n) times. This function allocates, fills, and
-returns a new array. For a lazy version, refer to $(XREF range, repeat).
+returns a new array. For a lazy version, refer to $(REF repeat, std,range).
  */
 ElementEncodingType!S[] replicate(S)(S s, size_t n) if (isDynamicArray!S)
 {
@@ -1330,7 +1330,7 @@ See_Also:
 $(XREF_PACK algorithm,iteration,splitter) for a version that splits using any
 separator.
 
-$(XREF regex, splitter) for a version that splits using a regular
+$(REF splitter, std,regex) for a version that splits using a regular
 expression defined separator.
 +/
 S[] split(S)(S s) @safe pure
diff --git a/std/bigint.d b/std/bigint.d
index 10b50fc8377..0bbc780597a 100644
--- a/std/bigint.d
+++ b/std/bigint.d
@@ -632,7 +632,7 @@ public:
     /**
         Implements casting to integer types.
 
-        Throws: $(XREF conv,ConvOverflowException) if the number exceeds
+        Throws: $(REF ConvOverflowException, std,conv) if the number exceeds
         the target type's range.
      */
     T opCast(T:ulong)() /*pure*/ const
diff --git a/std/complex.d b/std/complex.d
index 3253d258ce6..239ff2c314d 100644
--- a/std/complex.d
+++ b/std/complex.d
@@ -108,10 +108,10 @@ struct Complex(T)  if (isFloatingPoint!T)
     /** Converts the complex number to a string representation.
 
     The second form of this function is usually not called directly;
-    instead, it is used via $(XREF string,format), as shown in the examples
+    instead, it is used via $(REF format, std,string), as shown in the examples
     below.  Supported format characters are 'e', 'f', 'g', 'a', and 's'.
 
-    See the $(MREF std, format) and $(XREF string, format)
+    See the $(MREF std, format) and $(REF format, std,string)
     documentation for more information.
     */
     string toString() const /* TODO: @safe pure nothrow */
@@ -822,7 +822,7 @@ unittest{
 
     Note:
     $(D expi) is included here for convenience and for easy migration of code
-    that uses $(XREF math,_expi).  Unlike $(XREF math,_expi), which uses the
+    that uses $(REF _expi, std,math).  Unlike $(REF _expi, std,math), which uses the
     x87 $(I fsincos) instruction when possible, this function is no faster
     than calculating cos(y) and sin(y) separately.
 */
diff --git a/std/concurrency.d b/std/concurrency.d
index 50f67d48d2f..1c9a0a511ad 100644
--- a/std/concurrency.d
+++ b/std/concurrency.d
@@ -259,7 +259,7 @@ class LinkTerminated : Exception
 
 /**
  * Thrown if a message was sent to a thread via
- * $(XREF concurrency, prioritySend) and the receiver does not have a handler
+ * $(REF prioritySend, std,concurrency) and the receiver does not have a handler
  * for a message of this type.
  */
 class PriorityMessageException : Exception
@@ -596,7 +596,7 @@ unittest
  * Places the values as a message at the back of tid's message queue.
  *
  * Sends the supplied value to the thread represented by tid.  As with
- * $(XREF concurrency, spawn), $(D T) must not have unshared aliasing.
+ * $(REF spawn, std,concurrency), $(D T) must not have unshared aliasing.
  */
 void send(T...)( Tid tid, T vals )
 {
@@ -648,10 +648,10 @@ private void _send(T...)( MsgType type, Tid tid, T vals )
  * specified types are available.  This function works by pattern matching
  * a message against a set of delegates and executing the first match found.
  *
- * If a delegate that accepts a $(XREF variant, Variant) is included as
+ * If a delegate that accepts a $(REF Variant, std,variant) is included as
  * the last argument to $(D receive), it will match any message that was not
  * matched by an earlier delegate.  If more than one argument is sent,
- * the $(D Variant) will contain a $(XREF typecons, Tuple) of all values
+ * the $(D Variant) will contain a $(REF Tuple, std,typecons) of all values
  * sent.
  *
  * Example:
@@ -740,7 +740,7 @@ private template receiveOnlyRet(T...)
  *          is received.
  *
  * Returns: The received message.  If $(D T.length) is greater than one,
- *          the message will be packed into a $(XREF typecons, Tuple).
+ *          the message will be packed into a $(REF Tuple, std,typecons).
  *
  * Example:
  * ---
diff --git a/std/container/rbtree.d b/std/container/rbtree.d
index bd4595c36a1..bf0a8d090e6 100644
--- a/std/container/rbtree.d
+++ b/std/container/rbtree.d
@@ -722,7 +722,7 @@ private struct RBRange(N)
  * of $(BIGOH lg(n)).
  *
  * To use a different comparison than $(D "a < b"), pass a different operator string
- * that can be used by $(XREF functional, binaryFun), or pass in a
+ * that can be used by $(REF binaryFun, std,functional), or pass in a
  * function, delegate, functor, or any type where $(D less(a, b)) results in a $(D bool)
  * value.
  *
diff --git a/std/conv.d b/std/conv.d
index cc6f4e2148f..82155c221f6 100644
--- a/std/conv.d
+++ b/std/conv.d
@@ -5204,7 +5204,7 @@ unittest
     (e.g from $(D int) to $(D long)).
 
     Note that the result is always mutable even if the original type was const
-    or immutable. In order to retain the constness, use $(XREF traits, Unsigned).
+    or immutable. In order to retain the constness, use $(REF Unsigned, std,traits).
  */
 auto unsigned(T)(T x) if (isIntegral!T)
 {
@@ -5278,7 +5278,7 @@ unittest
     (e.g from $(D uint) to $(D ulong)).
 
     Note that the result is always mutable even if the original type was const
-    or immutable. In order to retain the constness, use $(XREF traits, Signed).
+    or immutable. In order to retain the constness, use $(REF Signed, std,traits).
  */
 auto signed(T)(T x) if (isIntegral!T)
 {
diff --git a/std/digest/digest.d b/std/digest/digest.d
index 983aa70d996..688b2225df8 100644
--- a/std/digest/digest.d
+++ b/std/digest/digest.d
@@ -388,7 +388,7 @@ unittest
 
 /**
  * Checks whether the digest has a $(D blockSize) member, which contains the
- * digest's internal block size in bits. It is primarily used by $(XREF digest.hmac, HMAC).
+ * digest's internal block size in bits. It is primarily used by $(REF HMAC, std,digest.hmac).
  */
 
 template hasBlockSize(T)
diff --git a/std/digest/hmac.d b/std/digest/hmac.d
index 73621dbea24..b21f87a57f7 100644
--- a/std/digest/hmac.d
+++ b/std/digest/hmac.d
@@ -26,7 +26,7 @@ import std.meta : allSatisfy;
  * information about the block size, it can be supplied explicitly using
  * the second overload.
  *
- * This type conforms to $(XREF digest.digest, isDigest).
+ * This type conforms to $(REF isDigest, std,digest.digest).
  */
 
 version(StdDdoc)
@@ -142,7 +142,7 @@ if (hashBlockSize % 8 == 0)
 
     /**
      * Feeds a piece of data into the hash computation. This method allows the
-     * type to be used as an $(XREF range, OutputRange).
+     * type to be used as an $(REF OutputRange, std,range).
      *
      * Returns:
      * A reference to the digest for convenient chaining.
diff --git a/std/encoding.d b/std/encoding.d
index a4500d93998..5cb8faa914e 100644
--- a/std/encoding.d
+++ b/std/encoding.d
@@ -2197,7 +2197,7 @@ unittest
     r = Destination string
 
  See_Also:
-    $(XREF conv, to)
+    $(REF to, std,conv)
  */
 void transcode(Src,Dst)(immutable(Src)[] s,out immutable(Dst)[] r)
 in
diff --git a/std/exception.d b/std/exception.d
index 0e221784a65..2e659289967 100644
--- a/std/exception.d
+++ b/std/exception.d
@@ -1748,7 +1748,7 @@ Returns: A wrapper $(D struct) that preserves the range interface of $(D input).
 
 opSlice:
 Infinite ranges with slicing support must return an instance of
-$(XREF range, Take) when sliced with a specific lower and upper
+$(REF Take, std,range) when sliced with a specific lower and upper
 bound (see $(XREF_PACK range,primitives,hasSlicing)); $(D handle) deals with
 this by $(D take)ing 0 from the return value of the handler function and
 returning that when an exception is caught.
diff --git a/std/file.d b/std/file.d
index 1d40b6d9626..124b2708e5a 100644
--- a/std/file.d
+++ b/std/file.d
@@ -382,7 +382,7 @@ version (linux) @safe unittest
 }
 
 /********************************************
-Read and validates (using $(XREF utf, validate)) a text file. $(D S)
+Read and validates (using $(REF validate, std,utf)) a text file. $(D S)
 can be a type of array of characters of any width and constancy. No
 width conversion is performed; if the width of the characters in file
 $(D name) is different from the width of elements of $(D S),
@@ -442,7 +442,7 @@ Params:
 
 Throws: $(D FileException) on error.
 
-See_also: $(XREF stdio,toFile)
+See_also: $(REF toFile, std,stdio)
  */
 void write(R)(R name, const void[] buffer)
     if ((isInputRange!R && isSomeChar!(ElementEncodingType!R) || isSomeString!R) &&
@@ -2566,7 +2566,7 @@ else version (NetBSD)
  * Returns the full path of the current executable.
  *
  * Throws:
- * $(XREF object, Exception)
+ * $(REF Exception, std,object)
  */
 @trusted string thisExePath ()
 {
@@ -3903,7 +3903,7 @@ unittest
         path = The directory to iterate over.
         pattern  = String with wildcards, such as $(RED "*.d"). The supported
                    wildcard strings are described under
-                   $(XREF _path, globMatch).
+                   $(REF globMatch, std,_path).
         mode = Whether the directory's sub-directories should be iterated
                over depth-first ($(D_PARAM depth)), breadth-first
                ($(D_PARAM breadth)), or not at all ($(D_PARAM shallow)).
diff --git a/std/format.d b/std/format.d
index cab20124c7e..c7816d4bf35 100644
--- a/std/format.d
+++ b/std/format.d
@@ -131,7 +131,7 @@ private alias enforceFmt = enforceEx!FormatException;
    Params:
 
    w = Output is sent to this writer. Typical output writers include
-   $(XREF array,Appender!string) and $(XREF stdio,LockingTextWriter).
+   $(REF Appender!string, std,array) and $(REF LockingTextWriter, std,stdio).
 
    fmt = Format string.
 
@@ -6415,7 +6415,7 @@ unittest
 /*****************************************************
  * Format arguments into a string.
  *
- * Params: fmt  = Format string. For detailed specification, see $(XREF _format,formattedWrite).
+ * Params: fmt  = Format string. For detailed specification, see $(REF formattedWrite, std,_format).
  *         args = Variadic list of arguments to format into returned string.
  */
 immutable(Char)[] format(Char, Args...)(in Char[] fmt, Args args) if (isSomeChar!Char)
diff --git a/std/functional.d b/std/functional.d
index 300299d98f8..59a6d49fca1 100644
--- a/std/functional.d
+++ b/std/functional.d
@@ -784,7 +784,7 @@ unittest
 
 /**
 Takes multiple functions and adjoins them together. The result is a
-$(XREF typecons, Tuple) with one element per passed-in function. Upon
+$(REF Tuple, std,typecons) with one element per passed-in function. Upon
 invocation, the returned tuple is the adjoined results of all
 functions.
 
diff --git a/std/json.d b/std/json.d
index c7845b51681..aaf759a0dee 100644
--- a/std/json.d
+++ b/std/json.d
@@ -700,7 +700,7 @@ struct JSONValue
 
 /**
 Parses a serialized string and returns a tree of JSON values.
-Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
+Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
 Params:
     json = json-formatted string to parse
     maxDepth = maximum depth of nesting allowed, -1 disables depth checking
@@ -1068,7 +1068,7 @@ unittest
 
 /**
 Parses a serialized string and returns a tree of JSON values.
-Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
+Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
 Params:
     json = json-formatted string to parse
     options = enable decoding string representations of NaN/Inf as float values
diff --git a/std/net/curl.d b/std/net/curl.d
index 754da71493a..ff560cfbcd3 100644
--- a/std/net/curl.d
+++ b/std/net/curl.d
@@ -1975,7 +1975,7 @@ private mixin template Protocol()
      * theprotocol.netInterface = [ 192, 168, 1, 32 ];
      * ----
      *
-     * See: $(XREF socket, InternetAddress)
+     * See: $(REF InternetAddress, std,socket)
      */
     @property void netInterface(const(char)[] i)
     {
@@ -2628,7 +2628,7 @@ struct HTTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 
@@ -3308,7 +3308,7 @@ struct FTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 
@@ -3657,7 +3657,7 @@ struct SMTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 
diff --git a/std/numeric.d b/std/numeric.d
index 7fb32defe74..b7495b8fb12 100644
--- a/std/numeric.d
+++ b/std/numeric.d
@@ -1413,7 +1413,7 @@ than that for a Fibonacci search.
 References:
     "Algorithms for Minimization without Derivatives", Richard Brent, Prentice-Hall, Inc. (1973)
 
-See_Also: $(LREF findRoot), $(XREF math, isNormal)
+See_Also: $(LREF findRoot), $(REF isNormal, std,math)
 +/
 Tuple!(T, "x", Unqual!(ReturnType!DF), "y", T, "error")
 findLocalMin(T, DF)(
diff --git a/std/outbuffer.d b/std/outbuffer.d
index 953c88a36e2..d251066f657 100644
--- a/std/outbuffer.d
+++ b/std/outbuffer.d
@@ -322,12 +322,12 @@ class OutBuffer
      * Formats and writes its arguments in text format to the OutBuffer.
      *
      * Params:
-     *  fmt = format string as described in $(XREF format, formattedWrite)
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
      *  args = arguments to be formatted
      *
      * See_Also:
-     *  $(XREF stdio, _writef);
-     *  $(XREF format, formattedWrite);
+     *  $(REF _writef, std,stdio);
+     *  $(REF formattedWrite, std,format);
      */
     void writef(Char, A...)(in Char[] fmt, A args)
     {
@@ -348,12 +348,12 @@ class OutBuffer
      * followed by a newline.
      *
      * Params:
-     *  fmt = format string as described in $(XREF format, formattedWrite)
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
      *  args = arguments to be formatted
      *
      * See_Also:
-     *  $(XREF stdio, _writefln);
-     *  $(XREF format, formattedWrite);
+     *  $(REF _writefln, std,stdio);
+     *  $(REF formattedWrite, std,format);
      */
     void writefln(Char, A...)(in Char[] fmt, A args)
     {
diff --git a/std/parallelism.d b/std/parallelism.d
index ca836cedd43..4386bf2510a 100644
--- a/std/parallelism.d
+++ b/std/parallelism.d
@@ -414,7 +414,7 @@ meaning that any memory writes made in the thread that executed the $(D Task)
 are guaranteed to be visible in the calling thread after one of these functions
 returns.
 
-The $(XREF parallelism, task) and $(XREF parallelism, scopedTask) functions can
+The $(REF task, std,parallelism) and $(REF scopedTask, std,parallelism) functions can
 be used to create an instance of this struct.  See $(D task) for usage examples.
 
 Function results are returned from $(D yieldForce), $(D spinForce) and
@@ -733,7 +733,7 @@ struct Task(alias fun, Args...)
     newly created thread, then terminate the thread.  This can be used for
     future/promise parallelism.  An explicit priority may be given
     to the $(D Task).  If one is provided, its value is forwarded to
-    $(D core.thread.Thread.priority). See $(XREF parallelism, task) for
+    $(D core.thread.Thread.priority). See $(REF task, std,parallelism) for
     usage example.
     */
     void executeInNewThread() @trusted
@@ -771,8 +771,8 @@ ReturnType!F run(F, Args...)(F fpOrDelegate, ref Args args)
 /**
 Creates a $(D Task) on the GC heap that calls an alias.  This may be executed
 via $(D Task.executeInNewThread) or by submitting to a
-$(XREF parallelism, TaskPool).  A globally accessible instance of
-$(D TaskPool) is provided by $(XREF parallelism, taskPool).
+$(REF TaskPool, std,parallelism).  A globally accessible instance of
+$(D TaskPool) is provided by $(REF taskPool, std,parallelism).
 
 Returns:  A pointer to the $(D Task).
 
@@ -883,7 +883,7 @@ identical to the non-@safe case, but safety introduces some restrictions:
 1.  $(D fun) must be @safe or @trusted.
 
 2.  $(D F) must not have any unshared aliasing as defined by
-    $(XREF traits, hasUnsharedAliasing).  This means it
+    $(REF hasUnsharedAliasing, std,traits).  This means it
     may not be an unshared delegate or a non-shared class or struct
     with overloaded $(D opCall).  This also precludes accepting template
     alias parameters.
@@ -1000,7 +1000,7 @@ thread that executes the $(D Task) at the front of the queue when one is
 available and sleeps when the queue is empty.
 
 This class should usually be used via the global instantiation
-available via the $(XREF parallelism, taskPool) property.
+available via the $(REF taskPool, std,parallelism) property.
 Occasionally it is useful to explicitly instantiate a $(D TaskPool):
 
 1.  When you want $(D TaskPool) instances with multiple priorities, for example
@@ -3141,7 +3141,7 @@ public:
     Notes:
 
     @trusted overloads of this function are called for $(D Task)s if
-    $(XREF traits, hasUnsharedAliasing) is false for the $(D Task)'s
+    $(REF hasUnsharedAliasing, std,traits) is false for the $(D Task)'s
     return type or the function the $(D Task) executes is $(D pure).
     $(D Task) objects that meet all other requirements specified in the
     $(D @trusted) overloads of $(D task) and $(D scopedTask) may be created
diff --git a/std/path.d b/std/path.d
index 9458a117c42..74089d05e24 100644
--- a/std/path.d
+++ b/std/path.d
@@ -10,8 +10,8 @@
     between a _path that points to a directory and a _path that points to a
     file, and it does not know whether or not the object pointed to by the
     _path actually exists in the file system.
-    To differentiate between these cases, use $(XREF file,isDir) and
-    $(XREF file,exists).
+    To differentiate between these cases, use $(REF isDir, std,file) and
+    $(REF exists, std,file).
 
     Note that on Windows, both the backslash ($(D `\`)) and the slash ($(D `/`))
     are in principle valid directory separators.  This module treats them
@@ -3547,7 +3547,7 @@ unittest
     or is equal to $(D ".") or $(D "..").
 
     $(B It does $(I not) check whether the _path points to an existing file
-    or directory; use $(XREF file,exists) for this purpose.)
+    or directory; use $(REF exists, std,file) for this purpose.)
 
     On Windows, some special rules apply:
     $(UL
diff --git a/std/process.d b/std/process.d
index d394f39e400..f4ca34a6947 100644
--- a/std/process.d
+++ b/std/process.d
@@ -225,7 +225,7 @@ wait(spawnProcess("myapp", ["foo" : "bar"], Config.newEnv));
 
 Standard_streams:
 The optional arguments $(D stdin), $(D stdout) and $(D stderr) may
-be used to assign arbitrary $(XREF stdio,File) objects as the standard
+be used to assign arbitrary $(REF File, std,stdio) objects as the standard
 input, output and error streams, respectively, of the child process.  The
 former must be opened for reading, while the latter two must be opened for
 writing.  The default is for the child process to inherit the standard
@@ -260,14 +260,14 @@ Params:
 args    = An array which contains the program name as the zeroth element
           and any command-line arguments in the following elements.
 stdin   = The standard input stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for reading.
+          This can be any $(REF File, std,stdio) that is opened for reading.
           By default the child process inherits the parent's input
           stream.
 stdout  = The standard output stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for writing.
+          This can be any $(REF File, std,stdio) that is opened for writing.
           By default the child process inherits the parent's output stream.
 stderr  = The standard error stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for writing.
+          This can be any $(REF File, std,stdio) that is opened for writing.
           By default the child process inherits the parent's error stream.
 env     = Additional environment variables for the child process.
 config  = Flags that control process creation. See $(LREF Config)
@@ -281,7 +281,7 @@ A $(LREF Pid) object that corresponds to the spawned process.
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to pass one of the streams
+$(REF StdioException, std,stdio) on failure to pass one of the streams
     to the child process (Windows only).$(BR)
 $(CXREF exception,RangeError) if $(D args) is empty.
 */
@@ -1588,7 +1588,7 @@ Returns:
 A $(LREF Pipe) object that corresponds to the created _pipe.
 
 Throws:
-$(XREF stdio,StdioException) on failure.
+$(REF StdioException, std,stdio) on failure.
 */
 version (Posix)
 Pipe pipe() @trusted //TODO: @safe
@@ -1655,7 +1655,7 @@ struct Pipe
     /**
     Closes both ends of the pipe.
 
-    Normally it is not necessary to do this manually, as $(XREF stdio,File)
+    Normally it is not necessary to do this manually, as $(REF File, std,stdio)
     objects are automatically closed when there are no more references
     to them.
 
@@ -1664,7 +1664,7 @@ struct Pipe
     child process is platform dependent.)
 
     Throws:
-    $(XREF exception,ErrnoException) if an error occurs.
+    $(REF ErrnoException, std,exception) if an error occurs.
     */
     void close() @safe
     {
@@ -1729,14 +1729,14 @@ shellPath = The path to the shell to use to run the specified program.
             By default this is $(LREF nativeShell).
 
 Returns:
-A $(LREF ProcessPipes) object which contains $(XREF stdio,File)
+A $(LREF ProcessPipes) object which contains $(REF File, std,stdio)
 handles that communicate with the redirected streams of the child
 process, along with a $(LREF Pid) object that corresponds to the
 spawned process.
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to redirect any of the streams.$(BR)
+$(REF StdioException, std,stdio) on failure to redirect any of the streams.$(BR)
 
 Example:
 ---
@@ -2000,7 +2000,7 @@ unittest
 }
 
 /**
-Object which contains $(XREF stdio,File) handles that allow communication
+Object which contains $(REF File, std,stdio) handles that allow communication
 with a child process through its standard streams.
 */
 struct ProcessPipes
@@ -2013,7 +2013,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows writing to the child process'
+    An $(REF File, std,stdio) that allows writing to the child process'
     standard input stream.
 
     Throws:
@@ -2029,7 +2029,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows reading from the child process'
+    An $(REF File, std,stdio) that allows reading from the child process'
     standard output stream.
 
     Throws:
@@ -2045,7 +2045,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows reading from the child process'
+    An $(REF File, std,stdio) that allows reading from the child process'
     standard error stream.
 
     Throws:
@@ -2122,7 +2122,7 @@ value is the signal number.  (See $(LREF wait) for details.)
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to capture output.
+$(REF StdioException, std,stdio) on failure to capture output.
 */
 auto execute(in char[][] args,
              const string[string] env = null,
@@ -2981,7 +2981,7 @@ static:
 
     Throws:
     $(OBJECTREF Exception) if the environment variable does not exist,
-    or $(XREF utf,UTFException) if the variable contains invalid UTF-16
+    or $(REF UTFException, std,utf) if the variable contains invalid UTF-16
     characters (Windows only).
 
     See_also:
@@ -3016,7 +3016,7 @@ static:
     ---
 
     Throws:
-    $(XREF utf,UTFException) if the variable contains invalid UTF-16
+    $(REF UTFException, std,utf) if the variable contains invalid UTF-16
     characters (Windows only).
     */
     string get(in char[] name, string defaultValue = null) @safe
diff --git a/std/range/package.d b/std/range/package.d
index cd87a268fb9..e68555bef32 100644
--- a/std/range/package.d
+++ b/std/range/package.d
@@ -2967,7 +2967,7 @@ Take!(Repeat!T) repeat(T)(T value, size_t n)
 }
 
 /**
-Given callable ($(XREF traits, isCallable)) $(D fun), create as a range
+Given callable ($(REF isCallable, std,traits)) $(D fun), create as a range
 whose front is defined by successive calls to $(D fun()).
 This is especially useful to call function with global side effects (random
 functions), or to create ranges expressed as a single delegate, rather than
@@ -2981,7 +2981,7 @@ The resulting range will call $(D fun()) on every call to $(D front),
 and only when $(D front) is called, regardless of how the range is
 iterated.
 It is advised to compose generate with either
-$(XREF_PACK algorithm,iteration,cache) or $(XREF array,array), or to use it in a
+$(XREF_PACK algorithm,iteration,cache) or $(REF array, std,array), or to use it in a
 foreach loop.
 A by-value foreach loop means that the loop value is not $(D ref).
 
@@ -5370,7 +5370,7 @@ auto iota(B, E)(B begin, E end)
 }
 
 /**
-User-defined types such as $(XREF bigint, BigInt) are also supported, as long
+User-defined types such as $(REF BigInt, std,bigint) are also supported, as long
 as they can be incremented with $(D ++) and compared with $(D <) or $(D ==).
 */
 // Issue 6447
@@ -7274,7 +7274,7 @@ unittest
 /**
 Iterate over $(D range) with an attached index variable.
 
-Each element is a $(XREF typecons, Tuple) containing the index
+Each element is a $(REF Tuple, std,typecons) containing the index
 and the element, in that order, where the index member is named $(D index)
 and the element member is named $(D value).
 
@@ -9222,7 +9222,7 @@ struct NullSink
   It is important to note that as the resultant range is evaluated lazily,
   in the case of the version of $(D tee) that takes a function, the function
   will not actually be executed until the range is "walked" using functions
-  that evaluate ranges, such as $(XREF array,array) or
+  that evaluate ranges, such as $(REF array, std,array) or
   $(XREF_PACK algorithm,iteration,fold).
 
   Params:
diff --git a/std/stdio.d b/std/stdio.d
index df9d87a2cd9..decc26297c5 100644
--- a/std/stdio.d
+++ b/std/stdio.d
@@ -1480,7 +1480,7 @@ Params:
 buf = Buffer used to store the resulting line data. buf is
 resized as necessary.
 terminator = Line terminator (by default, $(D '\n')). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Returns:
@@ -1668,7 +1668,7 @@ is recommended if you want to process a complete file.
     /**
      * Read data from the file according to the specified
      * $(LINK2 std_format.html#_format-string, format specifier) using
-     * $(XREF _format,formattedRead).
+     * $(REF formattedRead, std,_format).
      */
     uint readf(Data...)(in char[] format, Data data)
     {
@@ -1899,7 +1899,7 @@ Char = Character type for each line, defaulting to $(D char).
 keepTerminator = Use $(D KeepTerminator.yes) to include the
 terminator at the end of each line.
 terminator = Line separator ($(D '\n') by default). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Example:
@@ -2058,7 +2058,7 @@ Char = Character type for each line, defaulting to $(D immutable char).
 keepTerminator = Use $(D KeepTerminator.yes) to include the
 terminator at the end of each line.
 terminator = Line separator ($(D '\n') by default). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Example:
@@ -2076,7 +2076,7 @@ void main()
 }
 ----
 See_Also:
-$(XREF file,readText)
+$(REF readText, std,file)
 */
     auto byLineCopy(Terminator = char, Char = immutable char)
             (KeepTerminator keepTerminator = KeepTerminator.no,
@@ -3568,7 +3568,7 @@ unittest
 /**
  * Read data from $(D stdin) according to the specified
  * $(LINK2 std_format.html#format-string, format specifier) using
- * $(XREF format,formattedRead).
+ * $(REF formattedRead, std,format).
  */
 uint readf(A...)(in char[] format, A args)
 {
@@ -3632,7 +3632,7 @@ if (isSomeString!S)
  *        $(D size_t) 0 for end of file, otherwise number of characters read
  * Params:
  *        buf = Buffer used to store the resulting line data. buf is resized as necessary.
- *        terminator = Line terminator (by default, $(D '\n')). Use $(XREF ascii, newline)
+ *        terminator = Line terminator (by default, $(D '\n')). Use $(REF newline, std,ascii)
  *        for portability (unless the file was opened in text mode).
  * Throws:
  *        $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
@@ -4173,7 +4173,7 @@ unittest
 /**
 Writes an array or range to a file.
 Shorthand for $(D data.copy(File(fileName, "wb").lockingBinaryWriter)).
-Similar to $(XREF file,write), strings are written as-is,
+Similar to $(REF write, std,file), strings are written as-is,
 rather than encoded according to the $(D File)'s $(WEB
 en.cppreference.com/w/c/io#Narrow_and_wide_orientation,
 orientation).
diff --git a/std/string.d b/std/string.d
index 3ec93e66ec5..aa86065a304 100644
--- a/std/string.d
+++ b/std/string.d
@@ -376,7 +376,7 @@ alias CaseSensitive = Flag!"caseSensitive";
 
     Throws:
         If the sequence starting at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
   +/
 ptrdiff_t indexOf(Range)(Range s, in dchar c,
@@ -699,7 +699,7 @@ unittest
 
     Throws:
         If the sequence starting at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     Bugs:
         Does not work with case insensitive strings where the mapping of
@@ -971,7 +971,7 @@ unittest
 
     Throws:
         If the sequence ending at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     $(D cs) indicates whether the comparisons are case sensitive.
   +/
@@ -1157,7 +1157,7 @@ ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in size_t startIdx,
 
     Throws:
         If the sequence ending at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     $(D cs) indicates whether the comparisons are case sensitive.
   +/
@@ -1538,7 +1538,7 @@ private ptrdiff_t indexOfAnyNeitherImpl(bool forward, bool any, Char, Char2)(
     then $(D -1) is returned. The $(D startIdx) slices $(D haystack) in the
     following way $(D haystack[startIdx .. $]). $(D startIdx) represents a
     codeunit index in $(D haystack). If the sequence ending at $(D startIdx)
-    does not represent a well formed codepoint, then a $(XREF utf,UTFException)
+    does not represent a well formed codepoint, then a $(REF UTFException, std,utf)
     may be thrown.
 
     Params:
@@ -1707,7 +1707,7 @@ ptrdiff_t indexOfAny(Char,Char2)(const(Char)[] haystack, const(Char2)[] needles,
     then $(D -1) is returned. The $(D stopIdx) slices $(D haystack) in the
     following way $(D s[0 .. stopIdx]). $(D stopIdx) represents a codeunit
     index in $(D haystack). If the sequence ending at $(D startIdx) does not
-    represent a well formed codepoint, then a $(XREF utf,UTFException) may be
+    represent a well formed codepoint, then a $(REF UTFException, std,utf) may be
     thrown.
 
     Params:
@@ -2281,7 +2281,7 @@ auto representation(Char)(Char[] s) @safe pure nothrow @nogc
  *     The capitalized string.
  *
  * See_Also:
- *      $(XREF uni, asCapitalized) for a lazy range version that doesn't allocate memory
+ *      $(REF asCapitalized, std,uni) for a lazy range version that doesn't allocate memory
  */
 S capitalize(S)(S input) @trusted pure
     if (isSomeString!S)
@@ -2350,8 +2350,8 @@ auto capitalize(S)(auto ref S s)
 
 /++
     Split $(D s) into an array of lines according to the unicode standard using
-    $(D '\r'), $(D '\n'), $(D "\r\n"), $(XREF uni, lineSep),
-    $(XREF uni, paraSep), $(D U+0085) (NEL), $(D '\v')  and $(D '\f')
+    $(D '\r'), $(D '\n'), $(D "\r\n"), $(REF lineSep, std,uni),
+    $(REF paraSep, std,uni), $(D U+0085) (NEL), $(D '\v')  and $(D '\f')
     as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
     delimiter is included in the strings returned.
 
@@ -2371,8 +2371,8 @@ auto capitalize(S)(auto ref S s)
     array of strings, each element is a line that is a slice of $(D s)
   See_Also:
     $(LREF lineSplitter)
-    $(XREF algorithm, splitter)
-    $(XREF regex, splitter)
+    $(REF splitter, std,algorithm)
+    $(REF splitter, std,regex)
  +/
 alias KeepTerminator = Flag!"keepTerminator";
 
@@ -2679,7 +2679,7 @@ public:
 /***********************************
  *  Split an array or slicable range of characters into a range of lines
     using $(D '\r'), $(D '\n'), $(D '\v'), $(D '\f'), $(D "\r\n"),
-    $(XREF uni, lineSep), $(XREF uni, paraSep) and $(D '\u0085') (NEL)
+    $(REF lineSep, std,uni), $(REF paraSep, std,uni) and $(D '\u0085') (NEL)
     as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
     delimiter is included in the slices returned.
 
@@ -2698,8 +2698,8 @@ public:
 
   See_Also:
     $(LREF splitLines)
-    $(XREF algorithm, splitter)
-    $(XREF regex, splitter)
+    $(REF splitter, std,algorithm)
+    $(REF splitter, std,regex)
  */
 auto lineSplitter(KeepTerminator keepTerm = KeepTerminator.no, Range)(Range r)
     if ((hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) ||
@@ -2819,7 +2819,7 @@ unittest
 }
 
 /++
-    Strips leading whitespace (as defined by $(XREF uni, isWhite)).
+    Strips leading whitespace (as defined by $(REF isWhite, std,uni)).
 
     Params:
         input = string or ForwardRange of characters
@@ -2827,7 +2827,7 @@ unittest
     Returns: $(D input) stripped of leading whitespace.
 
     Postconditions: $(D input) and the returned value
-    will share the same tail (see $(XREF array, sameTail)).
+    will share the same tail (see $(REF sameTail, std,array)).
 
     See_Also:
         Generic stripping on ranges: $(REF _stripLeft, std, algorithm, mutation)
@@ -2893,7 +2893,7 @@ unittest
 }
 
 /++
-    Strips trailing whitespace (as defined by $(XREF uni, isWhite)).
+    Strips trailing whitespace (as defined by $(REF isWhite, std,uni)).
 
     Params:
         str = string or random access range of characters
@@ -3055,7 +3055,7 @@ unittest
 
 /++
     Strips both leading and trailing whitespace (as defined by
-    $(XREF uni, isWhite)).
+    $(REF isWhite, std,uni)).
 
     Params:
         str = string or random access range of characters
@@ -3158,7 +3158,7 @@ auto strip(Range)(auto ref Range str)
     $(D delimiter), then it is returned unchanged.
 
     If no $(D delimiter) is given, then one trailing  $(D '\r'), $(D '\n'),
-    $(D "\r\n"), $(D '\f'), $(D '\v'), $(XREF uni, lineSep), $(XREF uni, paraSep), or $(XREF uni, nelSep)
+    $(D "\r\n"), $(D '\f'), $(D '\v'), $(REF lineSep, std,uni), $(REF paraSep, std,uni), or $(REF nelSep, std,uni)
     is removed from the end of $(D str). If $(D str) does not end with any of those characters,
     then it is returned unchanged.
 
@@ -4744,7 +4744,7 @@ unittest
 
     See_Also:
         $(LREF tr)
-        $(XREF array, replace)
+        $(REF replace, std,array)
 
     Params:
         str        = The original string.
@@ -5012,7 +5012,7 @@ private void translateImpl(C1, T, C2, Buffer)(C1[] str,
 
     See_Also:
         $(LREF tr)
-        $(XREF array, replace)
+        $(REF replace, std,array)
 
     Params:
         str        = The original string.
@@ -5447,7 +5447,7 @@ S squeeze(S)(S s, in S pattern = null)
 /***************************************************************
  Finds the position $(D_PARAM pos) of the first character in $(D_PARAM
  s) that does not match $(D_PARAM pattern) (in the terminology used by
- $(XREF string,inPattern)). Updates $(D_PARAM s =
+ $(REF inPattern, std,string)). Updates $(D_PARAM s =
  s[pos..$]). Returns the slice from the beginning of the original
  (before update) string up to, and excluding, $(D_PARAM pos).
 
diff --git a/std/traits.d b/std/traits.d
index 1a5363dd7e2..9647ba6a2e4 100644
--- a/std/traits.d
+++ b/std/traits.d
@@ -3330,7 +3330,7 @@ Returns:
 Note:
  An enum can have multiple members which have the same value. If you want
  to use EnumMembers to e.g. generate switch cases at compile-time,
- you should use the $(XREF typetuple, NoDuplicates) template to avoid
+ you should use the $(REF NoDuplicates, std,typetuple) template to avoid
  generating duplicate switch cases.
 
 Note:
diff --git a/std/typecons.d b/std/typecons.d
index fc5dbfdb4f1..74cba92f063 100644
--- a/std/typecons.d
+++ b/std/typecons.d
@@ -310,7 +310,7 @@ for the second, and so on.
 
 The choice of zero-based indexing instead of one-base indexing was
 motivated by the ability to use value `Tuple`s with various compile-time
-loop constructs (e.g. $(XREF meta, AliasSeq) iteration), all of which use
+loop constructs (e.g. $(REF AliasSeq, std,meta) iteration), all of which use
 zero-based indexing.
 
 Params:
@@ -6888,7 +6888,7 @@ However, member types in `struct`s or `class`es are not replaced because there
 are no ways to express the types resulting after replacement.
 
 This is an advanced type manipulation necessary e.g. for replacing the
-placeholder type `This` in $(XREF variant, Algebraic).
+placeholder type `This` in $(REF Algebraic, std,variant).
 
 Returns: `ReplaceType` aliases itself to the type(s) that result after
 replacement.
diff --git a/std/typetuple.d b/std/typetuple.d
index d339364bbf1..032fa939675 100644
--- a/std/typetuple.d
+++ b/std/typetuple.d
@@ -12,7 +12,7 @@ module std.typetuple;
 public import std.meta;
 
 /**
- * Alternate name for $(XREF meta,AliasSeq) for legacy compatibility.
+ * Alternate name for $(REF AliasSeq, std,meta) for legacy compatibility.
  */
 alias TypeTuple = AliasSeq;
 
diff --git a/std/uni.d b/std/uni.d
index dd5c2391867..78280de3169 100644
--- a/std/uni.d
+++ b/std/uni.d
@@ -4,7 +4,7 @@
     $(P The $(D std.uni) module provides an implementation
     of fundamental Unicode algorithms and data structures.
     This doesn't include UTF encoding and decoding primitives,
-    see $(XREF _utf, decode) and $(XREF _utf, encode) in std.utf
+    see $(REF decode, std,_utf) and $(REF encode, std,_utf) in std.utf
     for this functionality. )
 
     $(P All primitives listed operate on Unicode characters and
@@ -1851,7 +1851,7 @@ public alias CodepointSet = InversionList!GcPolicy;
 // public alias CodepointInterval = Tuple!(uint, "a", uint, "b");
 
 /**
-    The recommended type of $(XREF _typecons, Tuple)
+    The recommended type of $(REF Tuple, std,_typecons)
     to represent [a, b$(RPAREN) intervals of $(CODEPOINTS). As used in $(LREF InversionList).
     Any interval type should pass $(LREF isIntegralPair) trait.
 */
@@ -2293,8 +2293,8 @@ public:
         open-right intervals and feed it to $(D sink).
         )
         $(P Used by various standard formatting facilities such as
-         $(XREF _format, formattedWrite), $(XREF _stdio, write),
-         $(XREF _stdio, writef), $(XREF _conv, to) and others.
+         $(REF formattedWrite, std,_format), $(REF write, std,_stdio),
+         $(REF writef, std,_stdio), $(REF to, std,_conv) and others.
         )
         Example:
         ---
@@ -4322,9 +4322,9 @@ private template buildTrie(Value, Key, Args...)
         In other words $(LREF mapTrieIndex) should be a
         monotonically increasing function that maps $(D Key) to an integer.
 
-        See_Also: $(XREF _algorithm, sort),
-        $(XREF _range, SortedRange),
-        $(XREF _algorithm, setUnion).
+        See_Also: $(REF sort, std,_algorithm),
+        $(REF SortedRange, std,_range),
+        $(REF setUnion, std,_algorithm).
     */
     auto buildTrie(Range)(Range range, Value filler=Value.init)
         if (isInputRange!Range && is(typeof(Range.init.front[0]) : Value)
@@ -7116,7 +7116,7 @@ unittest
 }
 
 /**
- * By using $(XREF utf, byUTF) and its aliases, GC allocations via auto-decoding
+ * By using $(REF byUTF, std,utf) and its aliases, GC allocations via auto-decoding
  * and thrown exceptions can be avoided, making `icmp` `@safe @nogc nothrow pure`.
  */
 @safe @nogc nothrow pure unittest
@@ -8203,7 +8203,7 @@ private auto toCaser(alias indexFn, uint maxIdx, alias tableFn, alias asciiConve
  *
  * Does not allocate memory.
  * Characters in UTF-8 or UTF-16 format that cannot be decoded
- * are treated as $(XREF utf, replacementDchar).
+ * are treated as $(REF replacementDchar, std,utf).
  *
  * Params:
  *      str = string or range of characters
@@ -8423,7 +8423,7 @@ private auto toCapitalizer(alias indexFnUpper, uint maxIdxUpper, alias tableFnUp
  *
  * Does not allocate memory.
  * Characters in UTF-8 or UTF-16 format that cannot be decoded
- * are treated as $(XREF utf, replacementDchar).
+ * are treated as $(REF replacementDchar, std,utf).
  *
  * Params:
  *      str = string or range of characters
@@ -8958,7 +8958,7 @@ unittest
     to produce an algorithm that can convert a range of characters to upper case
     without allocating memory.
     A string can then be produced by using $(XREF_PACK algorithm,mutation,copy)
-    to send it to an $(XREF array, appender).
+    to send it to an $(REF appender, std,array).
 +/
 @safe pure nothrow @nogc
 dchar toUpper(dchar c)
diff --git a/std/utf.d b/std/utf.d
index 8a91496495b..ff18b00f43f 100644
--- a/std/utf.d
+++ b/std/utf.d
@@ -3103,7 +3103,7 @@ enum dchar replacementDchar = '\uFFFD';
  * Iterate a range of char, wchar, or dchars by code unit.
  *
  * The purpose is to bypass the special case decoding that
- * $(XREF array,front) does to character arrays.
+ * $(REF front, std,array) does to character arrays.
  * Params:
  *      r = input range of characters, or array of characters
  * Returns:
diff --git a/std/uuid.d b/std/uuid.d
index b047e60296a..fca6b8fb67f 100644
--- a/std/uuid.d
+++ b/std/uuid.d
@@ -161,7 +161,7 @@ public struct UUID
          * possible to read, compare and use all these Variants, but
          * UUIDs generated by this module will always be in rfc4122 format.
          *
-         * Note: Do not confuse this with $(XREF _variant, _Variant).
+         * Note: Do not confuse this with $(REF _Variant, std,_variant).
          */
         enum Variant
         {
@@ -518,7 +518,7 @@ public struct UUID
          * RFC 4122 defines different internal data layouts for UUIDs.
          * Returns the format used by this UUID.
          *
-         * Note: Do not confuse this with $(XREF _variant, _Variant).
+         * Note: Do not confuse this with $(REF _Variant, std,_variant).
          * The type of this property is $(MYREF3 std.uuid.UUID.Variant, _Variant).
          *
          * See_Also:
@@ -1208,7 +1208,7 @@ unittest
 /**
  * Params:
  *      randomGen = uniform RNG
- * See_Also: $(XREF random, isUniformRNG)
+ * See_Also: $(REF isUniformRNG, std,random)
  */
 UUID randomUUID(RNG)(ref RNG randomGen)
 if (isInputRange!RNG && isIntegral!(ElementType!RNG))
diff --git a/std/zip.d b/std/zip.d
index 2b22d1b2549..cf101c86aa4 100644
--- a/std/zip.d
+++ b/std/zip.d
@@ -155,7 +155,7 @@ final class ArchiveMember
 
     /**
      * Set the OS specific file attributes, as obtained by
-     * $(XREF file,getAttributes) or $(XREF file,DirEntry.attributes), for this archive member.
+     * $(REF getAttributes, std,file) or $(REF DirEntry.attributes, std,file), for this archive member.
      */
     @property void fileAttributes(uint attr)
     {