use Typename for constructors with Int, Float32, etcetera

[stevengj]

The usual convention in Julia is that the constructor has the same name as the type, e.g. we construct an Array with Array(...) etcetera.

However, some of the bits types don't follow this rule: the constructor for Int is int(...), the constructor for Float64 is float64(...), etcetera. This is inconsistent, annoying, and confusing.

It is especially annoying because it means that a typealias for one of those types also does not have a constructor, e.g. there is no constructor for Cint. Of course, one could define cint(...) but that is annoying (not to mention polluting the namespace).

Right now, trying to define constructors named Float32 etcetera fails:

julia> import Core.Float32
julia> Float32(x) = float32(x)
ERROR: invalid method definition: not a generic function

I'm not sure if there is any deep technical reason for this limitation?

[andrioni]

Curiously, Float64 works.

julia> type T
       end

julia> Float64(::T) = 1.0
# methods for generic function Float64
Float64(::T) at none:1

Edit: OK, this is very weird.

julia> Float64(x) = x
ERROR: error in method definition: function Core.Float64 must be explicitly imported to be extended

julia> import Core.Float64

julia> Float64(x) = x
ERROR: invalid method definition: not a generic function

julia> Float32(x) = x
# methods for generic function Float32
Float32(x) at none:1

[JeffBezanson]

In the first case, you've created a new function called Float64, not related to Core.Float64.

[JeffBezanson]

I agree it would be much better not to have these redundant names.
One concern was that a constructor such as Int(x) ought to return something of type Int, while int(x) also converts arrays to element type Int. I suppose there ought to be a general version of that, something like arrayconvert(Int, a).

[StefanKarpinski]

map?

[blakejohnson]

What about, for instance, float()? In #2930 we used the fact that since this function was not a constructor for the type, we were free to convert a Complex{Int} to a Complex{Float64}.

[JeffBezanson]

Dup of #1470.