diff --git a/std/parallelism.d b/std/parallelism.d
@@ -1561,7 +1561,7 @@ public:
         preferred where the memory requirements of eagerness are acceptable.
         $(D functions) are the functions to be evaluated, passed as template
         alias parameters in a style similar to
-        $(XREF_PACK algorithm,iteration,map).
+        $(REF map, std,algorithm,iteration).
         The first argument must be a random access range. For performance
         reasons, amap will assume the range elements have not yet been
         initialized. Elements will be overwritten without calling a destructor
@@ -2344,7 +2344,7 @@ public:
     {
         /**
         Parallel reduce on a random access range.  Except as otherwise noted,
-        usage is similar to $(XREF_PACK algorithm,iteration,_reduce).  This
+        usage is similar to $(REF _reduce, std,algorithm,iteration).  This
         function works by splitting the range to be reduced into work units,
         which are slices to be reduced in parallel.  Once the results from all
         work units are computed, a final serial reduction is performed on these
@@ -2365,14 +2365,14 @@ public:
         algorithm. These take advantage of the instruction level parallelism of
         modern CPUs, in addition to the thread-level parallelism that the rest
         of this module exploits.  This can lead to better than linear speedups
-        relative to $(XREF_PACK algorithm,iteration,_reduce), especially for
+        relative to $(REF _reduce, std,algorithm,iteration), especially for
         fine-grained benchmarks like dot products.
 
         An explicit seed may be provided as the first argument.  If
         provided, it is used as the seed for all work units and for the final
         reduction of results from all work units.  Therefore, if it is not the
         identity value for the operation being performed, results may differ
-        from those generated by $(XREF_PACK algorithm,iteration,_reduce) or
+        from those generated by $(REF _reduce, std,algorithm,iteration) or
         depending on how many work units are used.  The next argument must be
         the range to be reduced.
         ---

diff --git a/std/range/package.d b/std/range/package.d
@@ -2976,12 +2976,12 @@ $(D fun) maybe be passed either a template alias parameter (existing
 function, delegate, struct type defining static $(D opCall)... ) or
 a run-time value argument (delegate, function object... ).
 The result range models an InputRange
-($(XREF_PACK range,primitives,isInputRange)).
+($(REF isInputRange, std,range,primitives)).
 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 $(REF array, std,array), or to use it in a
+$(REF cache, std,algorithm,iteration) 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).
 
@@ -7712,7 +7712,7 @@ Represents a sorted range. In addition to the regular range
 primitives, supports additional operations that take advantage of the
 ordering, such as merge and binary search. To obtain a $(D
 SortedRange) from an unsorted range $(D r), use
-$(XREF_PACK algorithm,sorting,sort) which sorts $(D r) in place and returns the
+$(REF sort, std,algorithm,sorting) which sorts $(D r) in place and returns the
 corresponding $(D SortedRange). To construct a $(D SortedRange) from a range
 $(D r) that is known to be already sorted, use $(LREF assumeSorted) described
 below.
@@ -8325,7 +8325,7 @@ effect on the complexity of subsequent operations specific to sorted
 ranges (such as binary search). The probability of an arbitrary
 unsorted range failing the test is very high (however, an
 almost-sorted range is likely to pass it). To check for sortedness at
-cost $(BIGOH n), use $(XREF_PACK algorithm,sorting,isSorted).
+cost $(BIGOH n), use $(REF isSorted, std,algorithm,sorting).
  */
 auto assumeSorted(alias pred = "a < b", R)(R r)
 if (isInputRange!(Unqual!R))
@@ -9223,7 +9223,7 @@ struct NullSink
   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 $(REF array, std,array) or
-  $(XREF_PACK algorithm,iteration,fold).
+  $(REF fold, std,algorithm,iteration).
 
   Params:
   pipeOnPop = If `Yes.pipeOnPop`, simply iterating the range without ever
@@ -9243,7 +9243,7 @@ struct NullSink
   iterated and returns its elements in turn. In addition, the same elements
   will be passed to `outputRange` or `fun` as well.
 
-  See_Also: $(XREF_PACK algorithm,iteration,each)
+  See_Also: $(REF each, std,algorithm,iteration)
 +/
 auto tee(Flag!"pipeOnPop" pipeOnPop = Yes.pipeOnPop, R1, R2)(R1 inputRange, R2 outputRange)
 if (isInputRange!R1 && isOutputRange!(R2, ElementType!R1))

diff --git a/std/stdio.d b/std/stdio.d
@@ -2416,7 +2416,7 @@ void main()
 }
 ---
 
-$(XREF_PACK algorithm,iteration,joiner) can be used to join chunks together into
+$(REF joiner, std,algorithm,iteration) can be used to join chunks together into
 a single range lazily.
 Example:
 ---

diff --git a/std/uni.d b/std/uni.d
@@ -6948,7 +6948,7 @@ unittest
 
     See_Also:
         $(LREF icmp)
-        $(XREF_PACK algorithm,comparison,cmp)
+        $(REF cmp, std,algorithm,comparison)
 +/
 int sicmp(S1, S2)(S1 str1, S2 str2) if (isSomeString!S1 && isSomeString!S2)
 {
@@ -7073,7 +7073,7 @@ private int fullCasedCmp(Range)(dchar lhs, dchar rhs, ref Range rtail)
 
     See_Also:
         $(LREF sicmp)
-        $(XREF_PACK algorithm,comparison,cmp)
+        $(REF cmp, std,algorithm,comparison)
 +/
 int icmp(S1, S2)(S1 str1, S2 str2)
     if (isForwardRange!S1 && is(Unqual!(ElementType!S1) == dchar)
@@ -8954,10 +8954,10 @@ unittest
     Certain alphabets like German and Greek have no 1:1
     upper-lower mapping. Use overload of toUpper which takes full string instead.
 
-    toUpper can be used as an argument to $(XREF_PACK algorithm,iteration,map)
+    toUpper can be used as an argument to $(REF map, std,algorithm,iteration)
     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)
+    A string can then be produced by using $(REF copy, std,algorithm,mutation)
     to send it to an $(REF appender, std,array).
 +/
 @safe pure nothrow @nogc