Issue 1:
I see two different conventions being used for including optional arguments in docstrings, one where the argument alone is wrapped in [arg], and one where the preceding comma is included [, arg]. I happen to find the second one a bit visually confusing, but the first one looks like a vector is created so it's not really optimal either. What are peoples thoughts about this? Should base try to at least be consistent here? Below is an example where the two styles are mixed up, sometimes even on the same line

help?> round
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]) # comma included for the first argument but not the second?
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; digits=, base=10) # what's up with the value for digits?
round(z::Complex[, RoundingModeReal, [RoundingModeImaginary]]; sigdigits=, base=10)

───────────────────────────────────────────────────────────────────────────────────────────

round([T,] x, [r::RoundingMode]) # comma included for T but not for r
round(x, [r::RoundingMode]; digits::Integer=0, base = 10) # comma not included for r
round(x, [r::RoundingMode]; sigdigits::Integer, base = 10)

I guess it's not the biggest of problems, but the inconsistencies may be a bit confusing, especially to newcomers who need to take in all the other language syntax at the same time.

Issue 2:
In investigating what appeared to be a code coverage issue with CSV.jl, @omus and I stumbled upon an unusual dispatch issue. It can be summarized like this:

julia> function foo(x=Type)
println("foo")
end;

julia> function foo{T}(x::T)
println("Method foo{T}")
end;

julia> foo()
Method foo{T}

As @omus has pointed out, the issue is that this:

function foo(x=Type)
println("foo")
end

is lowered to:

function foo()
foo(Type)
end

function foo(x)
println("foo")
end

function foo{T}(x::T)
println("Method foo{T}")
end

and since foo{T}(x::T) is deemed more specific than foo(x), foo{T}(x::T) is called instead of foo(x).

It seems like a warning might be appropriate in this case.

In the above example, I get the same behaviour on both 0.5 and 0.6, using these versions:

julia> versioninfo()
Julia Version 0.5.1-pre+55
Commit 8d4ef37* (2017-02-13 09:11 UTC)
Platform Info:
System: Darwin (x86_64-apple-darwin16.4.0)
CPU: Intel(R) Core(TM) i7-6567U CPU @ 3.30GHz
WORD_SIZE: 64
BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell)
LAPACK: libopenblas64_
LIBM: libopenlibm
LLVM: libLLVM-3.7.1 (ORCJIT, broadwell)

julia> versioninfo()
Julia Version 0.6.0-pre.alpha.5
Commit b1242df* (2017-02-28 18:33 UTC)
Platform Info:
OS: macOS (x86_64-apple-darwin16.4.0)
CPU: Intel(R) Core(TM) i7-6567U CPU @ 3.30GHz
WORD_SIZE: 64
BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell)
LAPACK: libopenblas64_
LIBM: libopenlibm
LLVM: libLLVM-3.9.1 (ORCJIT, skylake)

However, I get different behaviour depending on whether I call foo() in between the definitions.

In 0.5:

julia> function foo(x=Type)
println("foo")
end;

julia> foo()
foo

julia> function foo{T}(x::T)
println("Method foo{T}")
end;

julia> foo()
foo

In 0.6:

julia> function foo(x=Type)
println("foo")
end;

julia> foo()
foo

julia> function foo{T}(x::T)
println("Method foo{T}")
end;

julia> foo()
Method foo{T}