regenerate the manual

Author: MikeInnes

doc/devdocs/cartesian.rst

@@ -137,6 +137,7 @@ Macro reference
 ~~~~~~~~~~~~~~~
 
 .. function:: @nloops N itersym rangeexpr bodyexpr
+
               @nloops N itersym rangeexpr preexpr bodyexpr
               @nloops N itersym rangeexpr preexpr postexpr bodyexpr
 
@@ -191,6 +192,7 @@ Macro reference
     bounds-checking.
 
 .. function:: @nif N conditionexpr expr
+
               @nif N conditionexpr expr elseexpr
 
     Generates a sequence of ``if ... elseif ... else ... end`` statements. For example::
@@ -200,6 +202,7 @@ Macro reference
     would generate::
 
         if i_1 > size(A, 1)
+
 	    error("Dimension ", 1, " too big")
         elseif i_2 > size(A, 2)
 	    error("Dimension ", 2, " too big")

doc/stdlib/arrays.rst

@@ -90,8 +90,28 @@
    on the pointers ``dest`` and ``src`` to ensure that they are valid.
    Incorrect usage may corrupt or segfault your program, in the same manner as C.
 
+   ``unsafe_copy!(dest::Array, do, src::Array, so, N)``
+
+   Copy ``N`` elements from a source array to a destination, starting at offset ``so``
+   in the source and ``do`` in the destination (1-indexed).
+
+   The ``unsafe`` prefix on this function indicates that no validation is performed
+   to ensure that N is inbounds on either array. Incorrect usage may corrupt or segfault
+   your program, in the same manner as C.
+
 .. function:: unsafe_copy!(dest::Array, do, src::Array, so, N)
 
+   ``unsafe_copy!(dest::Ptr{T}, src::Ptr{T}, N)``
+
+   Copy ``N`` elements from a source pointer to a destination, with no checking. The
+   size of an element is determined by the type of the pointers.
+
+   The ``unsafe`` prefix on this function indicates that no validation is performed
+   on the pointers ``dest`` and ``src`` to ensure that they are valid.
+   Incorrect usage may corrupt or segfault your program, in the same manner as C.
+
+   ``unsafe_copy!(dest::Array, do, src::Array, so, N)``
+
    Copy ``N`` elements from a source array to a destination, starting at offset ``so``
    in the source and ``do`` in the destination (1-indexed).
 
@@ -103,8 +123,19 @@
 
    Copy all elements from collection ``src`` to array ``dest``. Returns ``dest``.
 
+   ``copy!(dest, do, src, so, N)``
+
+   Copy ``N`` elements from collection ``src`` starting at offset ``so``, to
+   array ``dest`` starting at offset ``do``. Returns ``dest``.
+
 .. function:: copy!(dest, do, src, so, N)
 
+   ``copy!(dest, src)``
+
+   Copy all elements from collection ``src`` to array ``dest``. Returns ``dest``.
+
+   ``copy!(dest, do, src, so, N)``
+
    Copy ``N`` elements from collection ``src`` starting at offset ``so``, to
    array ``dest`` starting at offset ``do``. Returns ``dest``.
 

doc/stdlib/base.rst

@@ -13,8 +13,18 @@
 
    Set the current working directory.
 
+   ``cd(f, [dir])``
+
+   Temporarily changes the current working directory (HOME if not specified) and applies function f before returning.
+
 .. function:: cd(f, [dir])
 
+   ``cd(dir::AbstractString)``
+
+   Set the current working directory.
+
+   ``cd(f, [dir])``
+
    Temporarily changes the current working directory (HOME if not specified) and applies function f before returning.
 
 .. function:: readdir([dir]) -> Vector{ByteString}
@@ -112,7 +122,7 @@
 .. function:: cp(src::AbstractString, dst::AbstractString; remove_destination::Bool=false, follow_symlinks::Bool=false)
 
    Copy the file, link, or directory from *src* to *dest*.
-   \"remove_destination=true\" will first remove an existing `dst`.
+   "remove_destination=true" will first remove an existing `dst`.
 
    If `follow_symlinks=false`, and src is a symbolic link, dst will be created as a symbolic link.
    If `follow_symlinks=true` and src is a symbolic link, dst will be a copy of the file or directory
@@ -129,7 +139,7 @@
 .. function:: mv(src::AbstractString,dst::AbstractString; remove_destination::Bool=false)
 
    Move the file, link, or directory from *src* to *dest*.
-   \"remove_destination=true\" will first remove an existing `dst`.
+   "remove_destination=true" will first remove an existing `dst`.
 
 .. function:: rm(path::AbstractString; recursive=false)
 
@@ -289,3 +299,4 @@
    If the last component of a path contains a dot, split the path into everything
    before the dot and everything including and after the dot. Otherwise, return
    a tuple of the argument unmodified and the empty string.
+

doc/stdlib/c.rst

@@ -40,7 +40,9 @@
 
 .. function:: time(t::TmStruct)
 
-   Converts a ``TmStruct`` struct to a number of seconds since the epoch.
+   ``time()``
+
+   Get the system time in seconds since the epoch, with fairly high (typically, microsecond) resolution.
 
 .. function:: strftime([format], time)
 
@@ -61,9 +63,9 @@
 
 .. function:: msync(ptr, len, [flags])
 
-   Forces synchronization of the :func:`mmap`\ ped memory region from ``ptr`` to ``ptr+len``. Flags defaults to ``MS_SYNC``, but can be a combination of ``MS_ASYNC``, ``MS_SYNC``, or ``MS_INVALIDATE``. See your platform man page for specifics. The flags argument is not valid on Windows.
+   ``msync(array)``
 
-   You may not need to call ``msync``, because synchronization is performed at intervals automatically by the operating system. However, you can call this directly if, for example, you are concerned about losing the result of a long-running calculation.
+   Forces synchronization between the in-memory version of a memory-mapped ``Array`` or ``BitArray`` and the on-disk version.
 
 .. data:: MS_ASYNC
 
@@ -84,3 +86,4 @@
 .. function:: munmap(pointer, len)
 
    Low-level interface for unmapping memory (see the man page). With :func:`mmap_array` you do not need to call this directly; the memory is unmapped for you when the array goes out of scope.
+

doc/stdlib/collections.rst

@@ -50,6 +50,16 @@ Data Formats
 
 .. function:: parse(type, str, [base])
 
+   ``parse(str, start; greedy=true, raise=true)``
+
+   Parse the expression string and return an expression (which could later be passed to eval for execution). Start is the index of the first character to start parsing. If ``greedy`` is true (default), ``parse`` will try to consume as much input as it can; otherwise, it will stop as soon as it has parsed a valid expression. Incomplete but otherwise syntactically valid expressions will return ``Expr(:incomplete, "(error message)")``. If ``raise`` is true (default), syntax errors other than incomplete expressions will raise an error. If ``raise`` is false, ``parse`` will return an expression that will raise an error upon evaluation.
+
+   ``parse(str; raise=true)``
+
+   Parse the whole string greedily, returning a single expression.  An error is thrown if there are additional characters after the first expression. If ``raise`` is true (default), syntax errors will raise an error; otherwise, ``parse`` will return an expression that will raise an error upon evaluation.
+
+   ``parse(type, str, [base])``
+
    Parse a string as a number. If the type is an integer type, then a base can be specified (the default is 10). If the type is a floating point type, the string is parsed as a decimal floating point number.
    If the string does not contain a valid number, an error is raised.
 
@@ -117,7 +127,6 @@ Data Formats
 
    Convert an array of bytes to its hexadecimal representation. All characters are in lower-case. Returns an ASCIIString.
 
-
 General Number Functions and Constants
 --------------------------------------
 
@@ -279,7 +288,6 @@ General Number Functions and Constants
       julia> big"2.1"
       2.099999999999999999999999999999999999999999999999999999999999999999999999999986e+00 with 256 bits of precision
 
-
 .. function:: get_rounding(T)
 
    Get the current floating point rounding mode for type ``T``, controlling
@@ -376,8 +384,31 @@ Integers
    	julia> isprime(3)
    	true
 
+   ``isprime(x::BigInt, [reps = 25]) -> Bool``
+
+   Probabilistic primality test. Returns ``true`` if ``x`` is prime; and
+   ``false`` if ``x`` is not prime with high probability. The false positive
+   rate is about ``0.25^reps``. ``reps = 25`` is considered safe for
+   cryptographic applications (Knuth, Seminumerical Algorithms).
+
+   .. doctest::
+
+   	julia> isprime(big(3))
+   	true
+
 .. function:: isprime(x::BigInt, [reps = 25]) -> Bool
 
+   ``isprime(x::Integer) -> Bool``
+
+   Returns ``true`` if ``x`` is prime, and ``false`` otherwise.
+
+   .. doctest::
+
+   	julia> isprime(3)
+   	true
+
+   ``isprime(x::BigInt, [reps = 25]) -> Bool``
+
    Probabilistic primality test. Returns ``true`` if ``x`` is prime; and
    ``false`` if ``x`` is not prime with high probability. The false positive
    rate is about ``0.25^reps``. ``reps = 25`` is considered safe for
@@ -507,3 +538,4 @@ As ``BigInt`` represents unbounded integers, the interval must be specified (e.g
 .. function:: randexp!([rng], A::Array{Float64,N})
 
    Fill the array A with random numbers following the exponential distribution (with scale 1).
+

doc/stdlib/dates.rst

@@ -15,8 +15,23 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
    that path is used in the returned value as ``joinpath(ENV["JULIA_PKGDIR"],"v$(VERSION.major).$(VERSION.minor)")``.
    If ``JULIA_PKGDIR`` is a relative path, it is interpreted relative to whatever the current working directory is.
 
+   ``dir(names...) -> AbstractString``
+
+   Equivalent to ``normpath(Pkg.dir(),names...)`` – i.e. it appends path components to the package directory and normalizes the resulting path.
+   In particular, ``Pkg.dir(pkg)`` returns the path to the package ``pkg``.
+
 .. function:: dir(names...) -> AbstractString
 
+   ``dir() -> AbstractString``
+
+   Returns the absolute path of the package directory.
+   This defaults to ``joinpath(homedir(),".julia","v$(VERSION.major).$(VERSION.minor)")`` on all platforms
+   (i.e. ``~/.julia/v0.4`` in UNIX shell syntax).  If the ``JULIA_PKGDIR`` environment variable is set, then
+   that path is used in the returned value as ``joinpath(ENV["JULIA_PKGDIR"],"v$(VERSION.major).$(VERSION.minor)")``.
+   If ``JULIA_PKGDIR`` is a relative path, it is interpreted relative to whatever the current working directory is.
+
+   ``dir(names...) -> AbstractString``
+
    Equivalent to ``normpath(Pkg.dir(),names...)`` – i.e. it appends path components to the package directory and normalizes the resulting path.
    In particular, ``Pkg.dir(pkg)`` returns the path to the package ``pkg``.
 
@@ -54,25 +69,59 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
    The package repo is cloned by the name ``pkg`` if provided;
    if not provided, ``pkg`` is determined automatically from ``url``.
 
+   ``clone(pkg)``
+
+   If ``pkg`` has a URL registered in ``Pkg.dir("METADATA")``, clone it from that URL on the default branch.
+   The package does not need to have any registered versions.
+
 .. function:: clone(pkg)
 
+   ``clone(url, [pkg])``
+
+   Clone a package directly from the git URL ``url``.
+   The package does not need to be a registered in ``Pkg.dir("METADATA")``.
+   The package repo is cloned by the name ``pkg`` if provided;
+   if not provided, ``pkg`` is determined automatically from ``url``.
+
+   ``clone(pkg)``
+
    If ``pkg`` has a URL registered in ``Pkg.dir("METADATA")``, clone it from that URL on the default branch.
    The package does not need to have any registered versions.
 
 .. function:: available() -> Vector{ASCIIString}
 
    Returns the names of available packages.
 
+   ``available(pkg) -> Vector{VersionNumber}``
+
+   Returns the version numbers available for package ``pkg``.
+
 .. function:: available(pkg) -> Vector{VersionNumber}
 
+   ``available() -> Vector{ASCIIString}``
+
+   Returns the names of available packages.
+
+   ``available(pkg) -> Vector{VersionNumber}``
+
    Returns the version numbers available for package ``pkg``.
 
 .. function:: installed() -> Dict{ASCIIString,VersionNumber}
 
    Returns a dictionary mapping installed package names to the installed version number of each package.
 
+   ``installed(pkg) -> Void | VersionNumber``
+
+   If ``pkg`` is installed, return the installed version number, otherwise return ``nothing``.
+
 .. function:: installed(pkg) -> Void | VersionNumber
 
+   ``installed() -> Dict{ASCIIString,VersionNumber}``
+
+   Returns a dictionary mapping installed package names to the installed version number of each package.
+
+   ``installed(pkg) -> Void | VersionNumber``
+
    If ``pkg`` is installed, return the installed version number, otherwise return ``nothing``.
 
 .. function:: status()
@@ -95,8 +144,19 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
    Pin ``pkg`` at the current version.
    To go back to using the newest compatible released version, use ``Pkg.free(pkg)``
 
+   ``pin(pkg, version)``
+
+   Pin ``pkg`` at registered version ``version``.
+
 .. function:: pin(pkg, version)
 
+   ``pin(pkg)``
+
+   Pin ``pkg`` at the current version.
+   To go back to using the newest compatible released version, use ``Pkg.free(pkg)``
+
+   ``pin(pkg, version)``
+
    Pin ``pkg`` at registered version ``version``.
 
 .. function:: free(pkg)
@@ -112,8 +172,19 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    Run the build scripts for all installed packages in depth-first recursive order.
 
+   ``build(pkgs...)``
+
+   Run the build script in "deps/build.jl" for each package in ``pkgs`` and all of their dependencies in depth-first recursive order.
+   This is called automatically by ``Pkg.resolve()`` on all installed or updated packages.
+
 .. function:: build(pkgs...)
 
+   ``build()``
+
+   Run the build scripts for all installed packages in depth-first recursive order.
+
+   ``build(pkgs...)``
+
    Run the build script in "deps/build.jl" for each package in ``pkgs`` and all of their dependencies in depth-first recursive order.
    This is called automatically by ``Pkg.resolve()`` on all installed or updated packages.
 
@@ -142,6 +213,17 @@ to use them, you'll need to prefix each function call with an explicit ``Pkg.``,
 
    Run the tests for all installed packages ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its ``test/runtests.jl`` file and test dependencies are specified in ``test/REQUIRE``.
 
+   ``test(pkgs...)``
+
+   Run the tests for each package in ``pkgs`` ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its ``test/runtests.jl`` file and test dependencies are specified in ``test/REQUIRE``.
+
 .. function:: test(pkgs...)
 
+   ``test()``
+
+   Run the tests for all installed packages ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its ``test/runtests.jl`` file and test dependencies are specified in ``test/REQUIRE``.
+
+   ``test(pkgs...)``
+
    Run the tests for each package in ``pkgs`` ensuring that each package's test dependencies are installed for the duration of the test. A package is tested by running its ``test/runtests.jl`` file and test dependencies are specified in ``test/REQUIRE``.
+

doc/stdlib/file.rst

@@ -15,7 +15,6 @@
    backtraces.
 
 .. currentmodule:: Base.Profile
-
 The methods in :mod:`Base.Profile` are not exported and need to be called e.g. as ``Profile.print()``.
 
 .. function:: clear()
@@ -32,8 +31,27 @@ The methods in :mod:`Base.Profile` are not exported and need to be called e.g. a
    correspond to the same line of code.  ``cols`` controls the width
    of the display.
 
+   ``print([io::IO = STDOUT,] data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols())``
+
+   Prints profiling results to ``io``. This variant is used to examine
+   results exported by a previous call to :func:`retrieve`.
+   Supply the vector ``data`` of backtraces and a dictionary
+   ``lidict`` of line information.
+
 .. function:: print([io::IO = STDOUT,] data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols())
 
+   ``print([io::IO = STDOUT,] [data::Vector]; format = :tree, C = false, combine = true, cols = tty_cols())``
+
+   Prints profiling results to ``io`` (by default, ``STDOUT``). If you
+   do not supply a ``data`` vector, the internal buffer of accumulated
+   backtraces will be used.  ``format`` can be ``:tree`` or
+   ``:flat``. If ``C==true``, backtraces from C and Fortran code are
+   shown. ``combine==true`` merges instruction pointers that
+   correspond to the same line of code.  ``cols`` controls the width
+   of the display.
+
+   ``print([io::IO = STDOUT,] data::Vector, lidict::Dict; format = :tree, combine = true, cols = tty_cols())``
+
    Prints profiling results to ``io``. This variant is used to examine
    results exported by a previous call to :func:`retrieve`.
    Supply the vector ``data`` of backtraces and a dictionary
@@ -86,3 +104,4 @@ The methods in :mod:`Base.Profile` are not exported and need to be called e.g. a
    (to force JIT-compilation), then call :func:`clear_malloc_data`.
    Then execute your command(s) again, quit Julia, and examine the
    resulting ``*.mem`` files.
+

doc/stdlib/io-network.rst

@@ -133,8 +133,18 @@ Sorting Functions
 
    Variant of ``sort!`` that returns a sorted copy of ``v`` leaving ``v`` itself unmodified.
 
+   ``sort(A, dim, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])``
+
+   Sort a multidimensional array ``A`` along the given dimension.
+
 .. function:: sort(A, dim, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
 
+   ``sort(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])``
+
+   Variant of ``sort!`` that returns a sorted copy of ``v`` leaving ``v`` itself unmodified.
+
+   ``sort(A, dim, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])``
+
    Sort a multidimensional array ``A`` along the given dimension.
 
 .. function:: sortperm(v, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
@@ -164,7 +174,6 @@ Sorting Functions
 
    Sort the columns of matrix ``A`` lexicographically.
 
-
 Order-Related Functions
 -----------------------
 
@@ -206,7 +215,6 @@ Order-Related Functions
    Variant of ``select!`` which copies ``v`` before partially sorting it, thereby
    returning the same thing as ``select!`` but leaving ``v`` unmodified.
 
-
 Sorting Algorithms
 ------------------
 

doc/stdlib/libc.rst

@@ -6,14 +6,42 @@
 
 .. function:: length(s)
 
+   ``length(A) -> Integer``
+
+   Returns the number of elements in A
+
+   ``length(collection) -> Integer``
+
+   For ordered, indexable collections, the maximum index ``i`` for which ``getindex(collection, i)`` is valid. For unordered collections, the number of elements.
+
+   ``length(s)``
+
    The number of characters in string ``s``.
 
 .. function:: sizeof(s::AbstractString)
 
+   ``sizeof(type)``
+
+   Size, in bytes, of the canonical binary representation of the given type, if any.
+
+   ``sizeof(s::AbstractString)``
+
    The number of bytes in string ``s``.
 
 .. function:: *(s, t)
 
+   ``*(A, B)``
+   :noindex:
+
+   Matrix multiplication
+
+   ``*(x, y...)``
+
+   Multiplication operator. ``x*y*z*...`` calls this function with all arguments, i.e.
+   ``*(x, y, z, ...)``.
+
+   ``*(s, t)``
+
    Concatenate strings. The ``*`` operator is an alias to this function.
 
    .. doctest::
@@ -23,6 +51,12 @@
 
 .. function:: ^(s, n)
 
+   ``^(x, y)``
+
+   Exponentiation operator.
+
+   ``^(s, n)``
+
    Repeat ``n`` times the string ``s``. The ``^`` operator is an alias to this function.
 
    .. doctest::
@@ -42,32 +76,98 @@
 
    Create a string from the address of a C (0-terminated) string encoded in ASCII or UTF-8. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
 
+   ``bytestring(s)``
+
+   Convert a string to a contiguous byte array representation appropriate for passing it to C functions. The string will be encoded as either ASCII or UTF-8.
+
 .. function:: bytestring(s)
 
+   ``bytestring(::Ptr{UInt8}, [length])``
+
+   Create a string from the address of a C (0-terminated) string encoded in ASCII or UTF-8. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
+
+   ``bytestring(s)``
+
    Convert a string to a contiguous byte array representation appropriate for passing it to C functions. The string will be encoded as either ASCII or UTF-8.
 
 .. function:: ascii(::Array{UInt8,1})
 
    Create an ASCII string from a byte array.
 
+   ``ascii(s)``
+
+   Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters).
+
+   ``ascii(::Ptr{UInt8}, [length])``
+
+   Create an ASCII string from the address of a C (0-terminated) string encoded in ASCII. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
+
 .. function:: ascii(s)
 
+   ``ascii(::Array{UInt8,1})``
+
+   Create an ASCII string from a byte array.
+
+   ``ascii(s)``
+
    Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters).
 
+   ``ascii(::Ptr{UInt8}, [length])``
+
+   Create an ASCII string from the address of a C (0-terminated) string encoded in ASCII. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
+
 .. function:: ascii(::Ptr{UInt8}, [length])
 
+   ``ascii(::Array{UInt8,1})``
+
+   Create an ASCII string from a byte array.
+
+   ``ascii(s)``
+
+   Convert a string to a contiguous ASCII string (all characters must be valid ASCII characters).
+
+   ``ascii(::Ptr{UInt8}, [length])``
+
    Create an ASCII string from the address of a C (0-terminated) string encoded in ASCII. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
 
 .. function:: utf8(::Array{UInt8,1})
 
    Create a UTF-8 string from a byte array.
 
+   ``utf8(::Ptr{UInt8}, [length])``
+
+   Create a UTF-8 string from the address of a C (0-terminated) string encoded in UTF-8. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
+
+   ``utf8(s)``
+
+   Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters).
+
 .. function:: utf8(::Ptr{UInt8}, [length])
 
+   ``utf8(::Array{UInt8,1})``
+
+   Create a UTF-8 string from a byte array.
+
+   ``utf8(::Ptr{UInt8}, [length])``
+
    Create a UTF-8 string from the address of a C (0-terminated) string encoded in UTF-8. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
 
+   ``utf8(s)``
+
+   Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters).
+
 .. function:: utf8(s)
 
+   ``utf8(::Array{UInt8,1})``
+
+   Create a UTF-8 string from a byte array.
+
+   ``utf8(::Ptr{UInt8}, [length])``
+
+   Create a UTF-8 string from the address of a C (0-terminated) string encoded in UTF-8. A copy is made; the ptr can be safely freed. If ``length`` is specified, the string does not have to be 0-terminated.
+
+   ``utf8(s)``
+
    Convert a string to a contiguous UTF-8 string (all characters must be valid UTF-8 characters).
 
 .. function:: normalize_string(s, normalform::Symbol)
@@ -114,15 +214,39 @@
    Returns true if the given value is valid for its type,
    which currently can be one of ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
 
+   ``isvalid(T, value) -> Bool``
+
+   Returns true if the given value is valid for that type.
+   Types currently can be ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
+   Values for ``Char`` can be of type ``Char`` or ``UInt32``
+   Values for ``ASCIIString`` and ``UTF8String`` can be of that type, or ``Vector{UInt8}``
+   Values for ``UTF16String`` can be ``UTF16String`` or ``Vector{UInt16}``
+   Values for ``UTF32String`` can be ``UTF32String``, ``Vector{Char}`` or ``Vector{UInt32}``
+
+   ``isvalid(str, i)``
+
+   Tells whether index ``i`` is valid for the given string
+
 .. function:: isvalid(T, value) -> Bool
 
+   ``isvalid(value) -> Bool``
+
+   Returns true if the given value is valid for its type,
+   which currently can be one of ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
+
+   ``isvalid(T, value) -> Bool``
+
    Returns true if the given value is valid for that type.
    Types currently can be ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
    Values for ``Char`` can be of type ``Char`` or ``UInt32``
    Values for ``ASCIIString`` and ``UTF8String`` can be of that type, or ``Vector{UInt8}``
    Values for ``UTF16String`` can be ``UTF16String`` or ``Vector{UInt16}``
    Values for ``UTF32String`` can be ``UTF32String``, ``Vector{Char}`` or ``Vector{UInt32}``
 
+   ``isvalid(str, i)``
+
+   Tells whether index ``i`` is valid for the given string
+
 .. function:: is_assigned_char(c) -> Bool
 
    Returns true if the given char or integer is an assigned Unicode code point.
@@ -249,6 +373,22 @@
 
 .. function:: isvalid(str, i)
 
+   ``isvalid(value) -> Bool``
+
+   Returns true if the given value is valid for its type,
+   which currently can be one of ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
+
+   ``isvalid(T, value) -> Bool``
+
+   Returns true if the given value is valid for that type.
+   Types currently can be ``Char``, ``ASCIIString``, ``UTF8String``, ``UTF16String``, or ``UTF32String``
+   Values for ``Char`` can be of type ``Char`` or ``UInt32``
+   Values for ``ASCIIString`` and ``UTF8String`` can be of that type, or ``Vector{UInt8}``
+   Values for ``UTF16String`` can be ``UTF16String`` or ``Vector{UInt16}``
+   Values for ``UTF32String`` can be ``UTF32String``, ``Vector{Char}`` or ``Vector{UInt32}``
+
+   ``isvalid(str, i)``
+
    Tells whether index ``i`` is valid for the given string
 
 .. function:: nextind(str, i)
@@ -377,31 +517,51 @@
    making a copy of the data and treating the NUL as a terminator
    rather than as part of the string.
 
-.. function:: utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])
+   ``utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])``
 
    Create a string from the address of a NUL-terminated UTF-16 string. A copy is made; the pointer can be safely freed. If ``length`` is specified, the string does not have to be NUL-terminated.
 
-.. function:: utf32(s)
+.. function:: utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])
 
-   Create a UTF-32 string from a byte array, array of ``Char`` or ``UInt32``, or
-   any other string type.  (Conversions of byte arrays check for a
-   byte-order marker in the first four bytes, and do not include it in
-   the resulting string.)
+   ``utf16(s)``
+
+   Create a UTF-16 string from a byte array, array of ``UInt16``, or
+   any other string type.  (Data must be valid UTF-16.  Conversions of
+   byte arrays check for a byte-order marker in the first two bytes,
+   and do not include it in the resulting string.)
 
-   Note that the resulting ``UTF32String`` data is terminated by the NUL
-   codepoint (32-bit zero), which is not treated as a character in the
+   Note that the resulting ``UTF16String`` data is terminated by the NUL
+   codepoint (16-bit zero), which is not treated as a character in the
    string (so that it is mostly invisible in Julia); this allows the
    string to be passed directly to external functions requiring
    NUL-terminated data.  This NUL is appended automatically by the
-   `utf32(s)` conversion function.  If you have a ``Char`` or ``UInt32`` array
-   ``A`` that is already NUL-terminated UTF-32 data, then you
-   can instead use `UTF32String(A)`` to construct the string without
+   `utf16(s)` conversion function.  If you have a ``UInt16`` array
+   ``A`` that is already NUL-terminated valid UTF-16 data, then you
+   can instead use `UTF16String(A)`` to construct the string without
    making a copy of the data and treating the NUL as a terminator
    rather than as part of the string.
 
+   ``utf16(::Union{Ptr{UInt16},Ptr{Int16}} [, length])``
+
+   Create a string from the address of a NUL-terminated UTF-16 string. A copy is made; the pointer can be safely freed. If ``length`` is specified, the string does not have to be NUL-terminated.
+
+.. function:: utf32(s)
+
+   ``wstring(s)``
+
+   This is a synonym for either ``utf32(s)`` or ``utf16(s)``,
+   depending on whether ``Cwchar_t`` is 32 or 16 bits, respectively.
+   The synonym ``WString`` for ``UTF32String`` or ``UTF16String``
+   is also provided.
+
 .. function:: utf32(::Union{Ptr{Char},Ptr{UInt32},Ptr{Int32}} [, length])
 
-   Create a string from the address of a NUL-terminated UTF-32 string. A copy is made; the pointer can be safely freed. If ``length`` is specified, the string does not have to be NUL-terminated.
+   ``wstring(s)``
+
+   This is a synonym for either ``utf32(s)`` or ``utf16(s)``,
+   depending on whether ``Cwchar_t`` is 32 or 16 bits, respectively.
+   The synonym ``WString`` for ``UTF32String`` or ``UTF16String``
+   is also provided.
 
 .. function:: wstring(s)
 
@@ -410,4 +570,3 @@
    The synonym ``WString`` for ``UTF32String`` or ``UTF16String``
    is also provided.
 
-

doc/stdlib/linalg.rst

@@ -17,9 +17,7 @@ binary install, you can run the test suite using ``Base.runtests()``.
    Run the Julia unit tests listed in ``tests``, which can be either a
    string or an array of strings, using ``numcores`` processors. (not exported)
 
-
 .. module:: Base.Test
-
 Test Framework
 --------------