Fix autolinks in /base

base/Enums.jl

@@ -29,7 +29,7 @@ end
 """
  @enum EnumName EnumValue1[=x] EnumValue2[=y]
 
-Create an [`Enum`](:obj:`Enum`) type with name `EnumName` and enum member values of
+Create an `Enum` type with name `EnumName` and enum member values of
 `EnumValue1` and `EnumValue2` with optional assigned values of `x` and `y`, respectively.
 `EnumName` can be used just like other types and enum member values as regular values, such as
 

base/abstractarray.jl

@@ -267,9 +267,9 @@ linearindexing(::LinearIndexing, ::LinearIndexing) = LinearSlow()
 Return `true` if the specified indices `I` are in bounds for the given
 array `A`. Subtypes of `AbstractArray` should specialize this method
 if they need to provide custom bounds checking behaviors; however, in
-many cases one can rely on `A`'s indices and [`checkindex`](:func:`checkindex`).
+many cases one can rely on `A`'s indices and [`checkindex`](@ref).
 
-See also [`checkindex`](:func:`checkindex`).
+See also [`checkindex`](@ref).
 """
 function checkbounds(::Type{Bool}, A::AbstractArray, I...)
  @_inline_meta
@@ -304,7 +304,7 @@ usually in a 1-for-1 fashion,
  checkbounds_indices(Bool, (IA1, IA...), (I1, I...)) = checkindex(Bool, IA1, I1) &
  checkbounds_indices(Bool, IA, I)
 
-Note that [`checkindex`](:func:`checkindex`) is being used to perform the actual
+Note that [`checkindex`](@ref) is being used to perform the actual
 bounds-check for a single dimension of the array.
 
 There are two important exceptions to the 1-1 rule: linear indexing and
@@ -714,8 +714,8 @@ A[iter] = 0
 ```
 
 If you supply more than one `AbstractArray` argument, `eachindex` will create an
-iterable object that is fast for all arguments (a [`UnitRange`](:obj:`UnitRange`)
-if all inputs have fast linear indexing, a [`CartesianRange`](:obj:`CartesianRange`)
+iterable object that is fast for all arguments (a `UnitRange`
+if all inputs have fast linear indexing, a `CartesianRange`
 otherwise).
 If the arrays have different sizes and/or dimensionalities, `eachindex` returns an
 iterable that spans the largest range along each dimension.
@@ -1512,7 +1512,7 @@ sub2ind(::Tuple{}, I::Integer...) = (@_inline_meta; _sub2ind((), 1, 1, I...))
 """
  sub2ind(dims, i, j, k...) -> index
 
-The inverse of [`ind2sub`](:func:`ind2sub`), returns the linear index corresponding to the provided subscripts.
+The inverse of [`ind2sub`](@ref), returns the linear index corresponding to the provided subscripts.
 
 ```jldoctest
 julia> sub2ind((5,6,7),1,2,3)
@@ -1789,7 +1789,7 @@ promote_eltype_op(op, A, B, C, D...) = (@_pure_meta; promote_eltype_op(op, eltyp
 """
  map!(function, collection)
 
-In-place version of [`map`](:func:`map`).
+In-place version of [`map`](@ref).
 """
 map!{F}(f::F, A::AbstractArray) = map!(f, A, A)
 function map!{F}(f::F, dest::AbstractArray, A::AbstractArray)
@@ -1848,7 +1848,7 @@ end
 """
  map!(function, destination, collection...)
 
-Like [`map`](:func:`map`), but stores the result in `destination` rather than a new
+Like [`map`](@ref), but stores the result in `destination` rather than a new
 collection. `destination` must be at least as large as the first collection.
 """
 map!{F}(f::F, dest::AbstractArray, As::AbstractArray...) = map_n!(f, dest, As)

base/abstractarraymath.jl

@@ -210,7 +210,7 @@ julia> circshift(b, (-1,0))
  1 5 9 13
 ```
 
-See also [`circshift!`](:func:`circshift!`).
+See also [`circshift!`](@ref).
 """
 function circshift(a::AbstractArray, shiftamt)
  circshift!(similar(a), a, map(Integer, (shiftamt...,)))

base/array.jl

@@ -261,7 +261,7 @@ julia> eye(A)
  0 0 1
 ```
 
-Note the difference from [`ones`](:func:`ones`).
+Note the difference from [`ones`](@ref).
 """
 eye{T}(x::AbstractMatrix{T}) = eye(T, size(x, 1), size(x, 2))
 

base/arraymath.jl

@@ -7,7 +7,7 @@
 
 Transform an array to its complex conjugate in-place.
 
-See also [`conj`](:func:`conj`).
+See also [`conj`](@ref).
 """
 function conj!{T<:Number}(A::AbstractArray{T})
  for i in eachindex(A)

base/associative.jl

@@ -115,7 +115,7 @@ end
  merge!(d::Associative, others::Associative...)
 
 Update collection with pairs from the other collections.
-See also [`merge`](:func:`merge`).
+See also [`merge`](@ref).
 """
 function merge!(d::Associative, others::Associative...)
  for other in others
@@ -138,7 +138,7 @@ end
 """
  keytype(type)
 
-Get the key type of an associative collection type. Behaves similarly to [`eltype`](:func:`eltype`).
+Get the key type of an associative collection type. Behaves similarly to [`eltype`](@ref).
 """
 keytype{K,V}(::Type{Associative{K,V}}) = K
 keytype(a::Associative) = keytype(typeof(a))
@@ -147,7 +147,7 @@ keytype{A<:Associative}(::Type{A}) = keytype(supertype(A))
 """
  valtype(type)
 
-Get the value type of an associative collection type. Behaves similarly to [`eltype`](:func:`eltype`).
+Get the value type of an associative collection type. Behaves similarly to [`eltype`](@ref).
 """
 valtype{K,V}(::Type{Associative{K,V}}) = V
 valtype{A<:Associative}(::Type{A}) = valtype(supertype(A))

base/asyncmap.jl

@@ -232,14 +232,14 @@ asyncmap(f, c...) = collect(AsyncGenerator(f, c...))
 """
  asyncmap!(f, c)
 
-In-place version of [`asyncmap()`](:func:`asyncmap`).
+In-place version of [`asyncmap()`](@ref).
 """
 asyncmap!(f, c) = (for x in AsyncCollector(f, c, c) end; c)
 
 
 """
  asyncmap!(f, results, c...)
 
-Like [`asyncmap()`](:func:`asyncmap`), but stores output in `results` rather returning a collection.
+Like [`asyncmap()`](@ref), but stores output in `results` rather returning a collection.
 """
 asyncmap!(f, r, c1, c...) = (for x in AsyncCollector(f, r, c1, c...) end; r)

base/base64.jl

@@ -19,7 +19,7 @@ export Base64EncodePipe, Base64DecodePipe, base64encode, base64decode
 
 Returns a new write-only I/O stream, which converts any bytes written to it into
 base64-encoded ASCII bytes written to `ostream`.
-Calling [`close`](:func:`close`) on the `Base64EncodePipe` stream
+Calling [`close`](@ref) on the `Base64EncodePipe` stream
 is necessary to complete the encoding (but does not close `ostream`).
 """
 type Base64EncodePipe <: IO
@@ -166,10 +166,10 @@ end
  base64encode(writefunc, args...)
  base64encode(args...)
 
-Given a [`write`](:func:`write`)-like function `writefunc`, which takes an I/O stream as its first argument,
+Given a [`write`](@ref)-like function `writefunc`, which takes an I/O stream as its first argument,
 `base64encode(writefunc, args...)` calls `writefunc` to write `args...` to a base64-encoded
 string, and returns the string. `base64encode(args...)` is equivalent to `base64encode(write, args...)`:
-it converts its arguments into bytes using the standard [`write`](:func:`write`) functions and returns the
+it converts its arguments into bytes using the standard [`write`](@ref) functions and returns the
 base64-encoded string.
 """
 function base64encode(f::Function, args...)

base/bitarray.jl

@@ -33,7 +33,7 @@ end
  BitArray{N}(dims::NTuple{N,Int})
 
 Construct an uninitialized `BitArray` with the given dimensions.
-Behaves identically to the [`Array`](:func:`Array`) constructor.
+Behaves identically to the [`Array`](@ref) constructor.
 """
 BitArray(dims::Integer...) = BitArray(map(Int,dims))
 BitArray{N}(dims::NTuple{N,Int}) = BitArray{N}(dims...)
@@ -1187,7 +1187,7 @@ end
 """
  flipbits!(B::BitArray{N}) -> BitArray{N}
 
-Performs a bitwise not operation on `B`. See [`~`](:ref:`~ operator <~>`).
+Performs a bitwise not operation on `B`. See [`~`](@ref).
 
 ```jldoctest
 julia> A = trues(2,2)
@@ -1632,7 +1632,7 @@ rol!(B::BitVector, i::Integer) = rol!(B, B, i)
 
 Performs a left rotation operation, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
-See also [`rol!`](:func:`rol!`).
+See also [`rol!`](@ref).
 
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])
@@ -1701,7 +1701,7 @@ ror!(B::BitVector, i::Integer) = ror!(B, B, i)
 
 Performs a right rotation operation on `B`, returning a new `BitVector`.
 `i` controls how far to rotate the bits.
-See also [`ror!`](:func:`ror!`).
+See also [`ror!`](@ref).
 
 ```jldoctest
 julia> A = BitArray([true, true, false, false, true])

base/broadcast.jl

@@ -183,7 +183,7 @@ end
 """
  broadcast!(f, dest, As...)
 
-Like [`broadcast`](:func:`broadcast`), but store the result of
+Like [`broadcast`](@ref), but store the result of
 `broadcast(f, As...)` in the `dest` array.
 Note that `dest` is only used to store the result, and does not supply
 arguments to `f` unless it is also listed in the `As`,
@@ -356,7 +356,7 @@ julia> string.(("one","two","three","four"), ": ", 1:4)
 """
  bitbroadcast(f, As...)
 
-Like [`broadcast`](:func:`broadcast`), but allocates a `BitArray` to store the
+Like [`broadcast`](@ref), but allocates a `BitArray` to store the
 result, rather then an `Array`.
 
 ```jldoctest
@@ -374,7 +374,7 @@ julia> bitbroadcast(isodd,[1,2,3,4,5])
 """
  broadcast_getindex(A, inds...)
 
-Broadcasts the `inds` arrays to a common size like [`broadcast`](:func:`broadcast`)
+Broadcasts the `inds` arrays to a common size like [`broadcast`](@ref)
 and returns an array of the results `A[ks...]`,
 where `ks` goes over the positions in the broadcast result `A`.
 

base/channels.jl

@@ -7,7 +7,7 @@ abstract AbstractChannel
 
 Constructs a `Channel` with an internal buffer that can hold a maximum of `sz` objects
 of type `T`.
-[`put!`](:func:`put!`) calls on a full channel block until an object is removed with [`take!`](:func:`take!`).
+[`put!`](@ref) calls on a full channel block until an object is removed with [`take!`](@ref).
 
 `Channel(0)` constructs an unbuffered channel. `put!` blocks until a matching `take!` is called.
 And vice-versa.
@@ -65,8 +65,8 @@ isbuffered(c::Channel) = c.sz_max==0 ? false : true
 
 Closes a channel. An exception is thrown by:
 
-* [`put!`](:func:`put!`) on a closed channel.
-* [`take!`](:func:`take!`) and [`fetch`](:func:`fetch`) on an empty, closed channel.
+* [`put!`](@ref) on a closed channel.
+* [`take!`](@ref) and [`fetch`](@ref) on an empty, closed channel.
 """
 function close(c::Channel)
  c.state = :closed
@@ -85,7 +85,7 @@ end
 
 Appends an item `v` to the channel `c`. Blocks if the channel is full.
 
-For unbuffered channels, blocks until a [`take!`](:func:`take!`) is performed by a different
+For unbuffered channels, blocks until a [`take!`](@ref) is performed by a different
 task.
 """
 function put!(c::Channel, v)
@@ -131,9 +131,9 @@ fetch_unbuffered(c::Channel) = throw(ErrorException("`fetch` is not supported on
 """
  take!(c::Channel)
 
-Removes and returns a value from a [`Channel`](:obj:`Channel`). Blocks until data is available.
+Removes and returns a value from a [`Channel`](@ref). Blocks until data is available.
 
-For unbuffered channels, blocks until a [`put!`](:func:`put!`) is performed by a different
+For unbuffered channels, blocks until a [`put!`](@ref) is performed by a different
 task.
 """
 take!(c::Channel) = isbuffered(c) ? take_buffered(c) : take_unbuffered(c)
@@ -167,11 +167,11 @@ end
 """
  isready(c::Channel)
 
-Determine whether a [`Channel`](:obj:`Channel`) has a value stored to it. Returns
+Determine whether a [`Channel`](@ref) has a value stored to it. Returns
 immediately, does not block.
 
 For unbuffered channels returns `true` if there are tasks waiting
-on a [`put!`](:func:`put!`).
+on a [`put!`](@ref).
 """
 isready(c::Channel) = n_avail(c) > 0
 n_avail(c::Channel) = isbuffered(c) ? length(c.data) : n_waiters(c.cond_put)

base/collections.jl

@@ -111,7 +111,7 @@ end
 """
  heapify!(v, ord::Ordering=Forward)
 
-In-place [`heapify`](:func:`heapify`).
+In-place [`heapify`](@ref).
 """
 function heapify!(xs::AbstractArray, o::Ordering=Forward)
  for i in heapparent(length(xs)):-1:1
@@ -182,7 +182,7 @@ end
 """
  PriorityQueue(K, V, [ord])
 
-Construct a new [`PriorityQueue`](:obj:`PriorityQueue`), with keys of type
+Construct a new [`PriorityQueue`](@ref), with keys of type
 `K` and values/priorites of type `V`.
 If an order is not given, the priority queue is min-ordered using
 the default comparison for `V`.

base/complex.jl

@@ -831,8 +831,8 @@ end
  round(z, RoundingModeReal, RoundingModeImaginary)
 
 Returns the nearest integral value of the same type as the complex-valued `z` to `z`,
-breaking ties using the specified [`RoundingMode`](:obj:`RoundingMode`)s. The first
-[`RoundingMode`](:obj:`RoundingMode`) is used for rounding the real components while the
+breaking ties using the specified [`RoundingMode`](@ref)s. The first
+[`RoundingMode`](@ref) is used for rounding the real components while the
 second is used for rounding the imaginary components.
 """
 function round{T<:AbstractFloat, MR, MI}(z::Complex{T}, ::RoundingMode{MR}, ::RoundingMode{MI})

base/datafmt.jl

@@ -703,7 +703,7 @@ end
  writedlm(f, A, delim='\\t'; opts)
 
 Write `A` (a vector, matrix, or an iterable collection of iterable rows) as text to `f`
-(either a filename string or an [`IO`](:class:`IO`) stream) using the given delimiter
+(either a filename string or an `IO` stream) using the given delimiter
 `delim` (which defaults to tab, but can be any printable Julia object, typically a `Char` or
 `AbstractString`).
 
@@ -715,7 +715,7 @@ writedlm(io, a; opts...) = writedlm(io, a, '\t'; opts...)
 """
  writecsv(filename, A; opts)
 
-Equivalent to [`writedlm`](:func:`writedlm`) with `delim` set to comma.
+Equivalent to [`writedlm`](@ref) with `delim` set to comma.
 """
 writecsv(io, a; opts...) = writedlm(io, a, ','; opts...)
 

base/dates/io.jl

@@ -88,8 +88,8 @@ duplicates(slots) = any(map(x->count(y->x.parser==y.parser,slots),slots) .> 1)
 
 Construct a date formatting object that can be used for parsing date strings or
 formatting a date object as a string. For details on the syntax for `format` see
-[`DateTime(::AbstractString, ::AbstractString)`](:ref:`parsing <man-date-parsing>`) and
-[`format`](:ref:`formatting <man-date-formatting>`).
+[`DateTime(::AbstractString, ::AbstractString)`](@ref) and
+[`format`](@ref).
 """
 function DateFormat(f::AbstractString, locale::AbstractString="english")
  slots = Slot[]
@@ -261,7 +261,7 @@ DateTime(dt::AbstractString,format::AbstractString;locale::AbstractString="engli
  DateTime(dt::AbstractString, df::DateFormat) -> DateTime
 
 Construct a `DateTime` by parsing the `dt` date string following the pattern given in
-the [`DateFormat`](:func:`Dates.DateFormat`) object. Similar to
+the [`DateFormat`](@ref) object. Similar to
 `DateTime(::AbstractString, ::AbstractString)` but more efficient when repeatedly parsing
 similarly formatted date strings with a pre-created `DateFormat` object.
 """

base/dates/periods.jl

@@ -18,7 +18,7 @@ for period in (:Year, :Month, :Week, :Day, :Hour, :Minute, :Second, :Millisecond
  # Period accessors
  typ_str = period in (:Hour, :Minute, :Second, :Millisecond) ? "DateTime" : "TimeType"
  description = typ_str == "TimeType" ? "`Date` or `DateTime`" : "`$typ_str`"
- reference = period == :Week ? " For details see [`$accessor_str(::$typ_str)`](:func:`$accessor_str`)." : ""
+ reference = period == :Week ? " For details see [`$accessor_str(::$typ_str)`](@ref)." : ""
  @eval begin
  @doc """
  $($period_str)(dt::$($typ_str)) -> $($period_str)