deprecate bin, oct, dec, hex, and base in favor of string and keywo…

…rd args (#25804)

* deprecate bin, oct, dec, hex, and base in favor of `string` and keyword args

* Work around inference problem in `div(::UInt128, ::UInt128)`

base/char.jl

@@ -165,7 +165,7 @@ function show(io::IO, ::MIME"text/plain", c::Char)
         else
             u = UInt32(c)
         end
-        h = hex(u, u ≤ 0xffff ? 4 : 6)
+        h = string(u, base = 16, pad = u ≤ 0xffff ? 4 : 6)
         print(io, (isascii(c) ? "ASCII/" : ""), "Unicode U+", h)
     else
         print(io, ": Malformed UTF-8")

base/deprecated.jl

@@ -419,8 +419,8 @@ function hex2num(s::AbstractString)
 end
 export hex2num
 
-@deprecate num2hex(x::Union{Float16,Float32,Float64}) hex(reinterpret(Unsigned, x), sizeof(x)*2)
-@deprecate num2hex(n::Integer) hex(n, sizeof(n)*2)
+@deprecate num2hex(x::Union{Float16,Float32,Float64}) string(reinterpret(Unsigned, x), base = 16, pad = sizeof(x)*2)
+@deprecate num2hex(n::Integer) string(n, base = 16, pad = sizeof(n)*2)
 
 # PR #22742: change in isapprox semantics
 @deprecate rtoldefault(x,y) rtoldefault(x,y,0) false
@@ -1394,6 +1394,25 @@ end
 
 @deprecate print_with_color(color, args...; kwargs...) printstyled(args...; kwargs..., color=color)
 
+@deprecate base(b, n)      string(n, base = b)
+@deprecate base(b, n, pad) string(n, base = b, pad = pad)
+@deprecate bin(n)          string(n, base = 2)
+@deprecate bin(n, pad)     string(n, base = 2, pad = pad)
+@deprecate oct(n)          string(n, base = 8)
+@deprecate oct(n, pad)     string(n, base = 8, pad = pad)
+@deprecate dec(n)          string(n)
+@deprecate dec(n, pad)     string(n, pad = pad)
+@deprecate hex(n)          string(n, base = 16)
+@deprecate hex(n, pad)     string(n, base = 16, pad = pad)
+@deprecate bin(n::Char)      string(UInt32(n), base = 2)
+@deprecate bin(n::Char, pad) string(UInt32(n), base = 2, pad = pad)
+@deprecate oct(n::Char)      string(UInt32(n), base = 8)
+@deprecate oct(n::Char, pad) string(UInt32(n), base = 8, pad = pad)
+@deprecate dec(n::Char)      string(UInt32(n))
+@deprecate dec(n::Char, pad) string(UInt32(n), pad = pad)
+@deprecate hex(n::Char)      string(UInt32(n), base = 16)
+@deprecate hex(n::Char, pad) string(UInt32(n), base = 16, pad = pad)
+
 @deprecate which(s::Symbol) which(Main, s)
 
 @deprecate IOBuffer(data::AbstractVector{UInt8}, read::Bool, write::Bool=false, maxsize::Integer=typemax(Int)) IOBuffer(data, read=read, write=write, maxsize=maxsize)

base/exports.jl

@@ -559,19 +559,15 @@ export
 
 # strings
     ascii,
-    base,
-    bin,
     bitstring,
     bytes2hex,
     chomp,
     chop,
     codeunit,
     codeunits,
-    dec,
     digits,
     digits!,
     escape_string,
-    hex,
     hex2bytes,
     hex2bytes!,
     isalpha,
@@ -594,7 +590,6 @@ export
     ncodeunits,
     ndigits,
     nextind,
-    oct,
     prevind,
     repeat,
     replace,

base/gmp.jl

@@ -7,7 +7,7 @@ export BigInt
 import .Base: *, +, -, /, <, <<, >>, >>>, <=, ==, >, >=, ^, (~), (&), (|), xor,
              binomial, cmp, convert, div, divrem, factorial, fld, gcd, gcdx, lcm, mod,
              ndigits, promote_rule, rem, show, isqrt, string, powermod,
-             sum, trailing_zeros, trailing_ones, count_ones, base, tryparse_internal,
+             sum, trailing_zeros, trailing_ones, count_ones, tryparse_internal,
              bin, oct, dec, hex, isequal, invmod, prevpow2, nextpow2, ndigits0zpb,
              widen, signed, unsafe_trunc, trunc, iszero, isone, big, flipsign, signbit,
              hastypemax
@@ -593,27 +593,16 @@ flipsign( x::BigInt, y::Integer) = signbit(y) ? -x : x
 flipsign( x::BigInt, y::BigInt)  = signbit(y) ? -x : x
 # above method to resolving ambiguities with flipsign(::T, ::T) where T<:Signed
 
-string(x::BigInt) = dec(x)
 show(io::IO, x::BigInt) = print(io, string(x))
 
-bin(n::BigInt) = base( 2, n)
-oct(n::BigInt) = base( 8, n)
-dec(n::BigInt) = base(10, n)
-hex(n::BigInt) = base(16, n)
-
-bin(n::BigInt, pad::Int) = base( 2, n, pad)
-oct(n::BigInt, pad::Int) = base( 8, n, pad)
-dec(n::BigInt, pad::Int) = base(10, n, pad)
-hex(n::BigInt, pad::Int) = base(16, n, pad)
-
-function base(b::Integer, n::BigInt, pad::Integer=1)
-    b < 0 && return base(Int(b), n, pad, (b>0) & (n.size<0))
-    2 <= b <= 62 || throw(ArgumentError("base must be 2 ≤ base ≤ 62, got $b"))
+function string(n::BigInt; base::Integer = 10, pad::Integer = 1)
+    base < 0 && return Base._base(Int(base), n, pad, (base>0) & (n.size<0))
+    2 <= base <= 62 || throw(ArgumentError("base must be 2 ≤ base ≤ 62, got $base"))
     iszero(n) && pad < 1 && return ""
-    nd1 = ndigits(n, b)
+    nd1 = ndigits(n, base)
     nd  = max(nd1, pad)
     sv  = Base.StringVector(nd + isneg(n))
-    GC.@preserve sv MPZ.get_str!(pointer(sv) + nd - nd1, b, n)
+    GC.@preserve sv MPZ.get_str!(pointer(sv) + nd - nd1, base, n)
     @inbounds for i = (1:nd-nd1) .+ isneg(n)
         sv[i] = '0' % UInt8
     end

base/grisu/grisu.jl

@@ -85,7 +85,7 @@ function _show(io::IO, x::AbstractFloat, mode, n::Int, typed, compact)
             write(io, '0')
         end
         write(io, (typed && isa(x,Float32)) ? 'f' : 'e')
-        write(io, dec(pt-1))
+        write(io, string(pt - 1))
         typed && isa(x,Float16) && write(io, ")")
         return
     elseif pt <= 0
@@ -160,7 +160,7 @@ function _print_shortest(io::IO, x::AbstractFloat, dot::Bool, mode, n::Int)
         # => ########e###
         unsafe_write(io, pdigits+0, len)
         write(io, 'e')
-        write(io, dec(e))
+        write(io, string(e))
         return
     elseif pt <= 0
         # => 0.000########

base/int.jl

@@ -330,10 +330,10 @@ julia> a = bswap(4)
 julia> bswap(a)
 4
 
-julia> bin(1)
+julia> string(1, base = 2)
 "1"
 
-julia> bin(bswap(1))
+julia> string(bswap(1), base = 2)
 "100000000000000000000000000000000000000000000000000000000"
 ```
 """
@@ -717,7 +717,7 @@ if Core.sizeof(Int) == 4
         return Int128(div(BigInt(x), BigInt(y)))
     end
     function div(x::UInt128, y::UInt128)
-        return UInt128(div(BigInt(x), BigInt(y)))
+        return UInt128(div(BigInt(x), BigInt(y)))::UInt128
     end
 
     function rem(x::Int128, y::Int128)

base/intfuncs.jl

@@ -558,16 +558,14 @@ julia> ndigits(12345)
 julia> ndigits(1022, 16)
 3
 
-julia> base(16, 1022)
+julia> string(1022, base = 16)
 "3fe"
 ```
 """
 ndigits(x::Integer, b::Integer, pad::Int=1) = max(pad, ndigits0z(x, b))
 
 ## integer to string functions ##
 
-string(x::Union{Int8,Int16,Int32,Int64,Int128}) = dec(x)
-
 function bin(x::Unsigned, pad::Int, neg::Bool)
     i = neg + max(pad,sizeof(x)<<3-leading_zeros(x))
     a = StringVector(i)
@@ -620,8 +618,7 @@ end
 const base36digits = ['0':'9';'a':'z']
 const base62digits = ['0':'9';'A':'Z';'a':'z']
 
-
-function base(b::Int, x::Integer, pad::Int, neg::Bool)
+function _base(b::Int, x::Integer, pad::Int, neg::Bool)
     (x >= 0) | (b < 0) || throw(DomainError(x, "For negative `x`, `b` must be negative."))
     2 <= abs(b) <= 62 || throw(ArgumentError("base must satisfy 2 ≤ abs(base) ≤ 62, got $b"))
     digits = abs(b) <= 36 ? base36digits : base62digits
@@ -641,97 +638,42 @@ function base(b::Int, x::Integer, pad::Int, neg::Bool)
     String(a)
 end
 
+split_sign(n::Integer) = unsigned(abs(n)), n < 0
+split_sign(n::Unsigned) = n, false
+
 """
-    base(base::Integer, n::Integer, pad::Integer=1)
+    string(n::Integer; base::Integer = 10, pad::Integer = 1)
 
 Convert an integer `n` to a string in the given `base`,
 optionally specifying a number of digits to pad to.
 
 ```jldoctest
-julia> base(13,5,4)
+julia> string(5, base = 13, pad = 4)
 "0005"
 
-julia> base(5,13,4)
+julia> string(13, base = 5, pad = 4)
 "0023"
 ```
 """
-base(b::Integer, n::Integer, pad::Integer=1) =
-    base(Int(b), b > 0 ? unsigned(abs(n)) : convert(Signed, n), Int(pad), (b>0) & (n<0))
-
-for sym in (:bin, :oct, :dec, :hex)
-    @eval begin
-        ($sym)(x::Unsigned, p::Int) = ($sym)(x,p,false)
-        ($sym)(x::Unsigned)         = ($sym)(x,1,false)
-        ($sym)(x::Char, p::Int)     = ($sym)(UInt32(x),p,false)
-        ($sym)(x::Char)             = ($sym)(UInt32(x),1,false)
-        ($sym)(x::Integer, p::Int)  = ($sym)(unsigned(abs(x)),p,x<0)
-        ($sym)(x::Integer)          = ($sym)(unsigned(abs(x)),1,x<0)
+function string(n::Integer; base::Integer = 10, pad::Integer = 1)
+    if base == 2
+        (n_positive, neg) = split_sign(n)
+        bin(n_positive, pad, neg)
+    elseif base == 8
+        (n_positive, neg) = split_sign(n)
+        oct(n_positive, pad, neg)
+    elseif base == 10
+        (n_positive, neg) = split_sign(n)
+        dec(n_positive, pad, neg)
+    elseif base == 16
+        (n_positive, neg) = split_sign(n)
+        hex(n_positive, pad, neg)
+    else
+        _base(Int(base), base > 0 ? unsigned(abs(n)) : convert(Signed, n), Int(pad), (base>0) & (n<0))
     end
 end
 
-"""
-    bin(n, pad::Int=1)
-
-Convert an integer to a binary string, optionally specifying a number of digits to pad to.
-
-```jldoctest
-julia> bin(10,2)
-"1010"
-
-julia> bin(10,8)
-"00001010"
-```
-"""
-bin
-
-"""
-    hex(n, pad::Int=1)
-
-Convert an integer to a hexadecimal string, optionally specifying a number of
-digits to pad to.
-
-```jldoctest
-julia> hex(20)
-"14"
-
-julia> hex(20, 3)
-"014"
-```
-"""
-hex
-
-"""
-    oct(n, pad::Int=1)
-
-Convert an integer to an octal string, optionally specifying a number of digits
-to pad to.
-
-```jldoctest
-julia> oct(20)
-"24"
-
-julia> oct(20, 3)
-"024"
-```
-"""
-oct
-
-"""
-    dec(n, pad::Int=1)
-
-Convert an integer to a decimal string, optionally specifying a number of digits
-to pad to.
-
-# Examples
-```jldoctest
-julia> dec(20)
-"20"
-
-julia> dec(20, 3)
-"020"
-```
-"""
-dec
+string(b::Bool) = b ? "true" : "false"
 
 """
     bitstring(n)
@@ -749,11 +691,11 @@ julia> bitstring(2.2)
 """
 function bitstring end
 
-bitstring(x::Union{Bool,Int8,UInt8})           = bin(reinterpret(UInt8,x),8)
-bitstring(x::Union{Int16,UInt16,Float16})      = bin(reinterpret(UInt16,x),16)
-bitstring(x::Union{Char,Int32,UInt32,Float32}) = bin(reinterpret(UInt32,x),32)
-bitstring(x::Union{Int64,UInt64,Float64})      = bin(reinterpret(UInt64,x),64)
-bitstring(x::Union{Int128,UInt128})            = bin(reinterpret(UInt128,x),128)
+bitstring(x::Union{Bool,Int8,UInt8})           = string(reinterpret(UInt8,x), pad = 8, base = 2)
+bitstring(x::Union{Int16,UInt16,Float16})      = string(reinterpret(UInt16,x), pad = 16, base = 2)
+bitstring(x::Union{Char,Int32,UInt32,Float32}) = string(reinterpret(UInt32,x), pad = 32, base = 2)
+bitstring(x::Union{Int64,UInt64,Float64})      = string(reinterpret(UInt64,x), pad = 64, base = 2)
+bitstring(x::Union{Int128,UInt128})            = string(reinterpret(UInt128,x), pad = 128, base = 2)
 
 """
     digits([T<:Integer], n::Integer; base::T = 10, pad::Integer = 1)

base/logging.jl

@@ -237,7 +237,7 @@ function log_record_id(_module, level, message_ex)
     # as we increment h to resolve any collisions.
     h = hash(string(modname, level, message_ex)) % (1<<31)
     while true
-        id = Symbol(modname, '_', hex(h, 8))
+        id = Symbol(modname, '_', string(h, base = 16, pad = 8))
         # _log_record_ids is a registry of log record ids for use during
         # compilation, to ensure uniqueness of ids.  Note that this state will
         # only persist during module compilation so it will be empty when a

base/operators.jl

@@ -782,14 +782,11 @@ entered in the Julia REPL (and most editors, appropriately configured) by typing
 
 # Examples
 ```jldoctest
-julia> map(uppercase∘hex, 250:255)
-6-element Array{String,1}:
- "FA"
- "FB"
- "FC"
- "FD"
- "FE"
- "FF"
+julia> map(uppercase∘first, ["apple", "banana", "carrot"])
+3-element Array{Char,1}:
+ 'A'
+ 'B'
+ 'C'
 ```
 """
 ∘(f, g) = (x...)->f(g(x...))
@@ -874,4 +871,4 @@ julia> map(splat(+), zip(1:3,4:6))
  9
 ```
 """
-splat(f) = args->f(args...)
+splat(f) = args->f(args...)

base/printf.jl

@@ -695,7 +695,7 @@ function gen_p(flags::String, width::Int, precision::Int, c::Char)
     end
     push!(blk.args, :(write(out, '0')))
     push!(blk.args, :(write(out, 'x')))
-    push!(blk.args, :(write(out, String(hex(unsigned($x), $ptrwidth)))))
+    push!(blk.args, :(write(out, String(string(unsigned($x), pad = $ptrwidth, base = 16)))))
     if width > 0 && '-' in flags
         push!(blk.args, pad(width, width, ' '))
     end

base/show.jl

@@ -341,7 +341,7 @@ function show_default(io::IO, @nospecialize(x))
         GC.@preserve r begin
             p = unsafe_convert(Ptr{Cvoid}, r)
             for i in (nb - 1):-1:0
-                print(io, hex(unsafe_load(convert(Ptr{UInt8}, p + i)), 2))
+                print(io, string(unsafe_load(convert(Ptr{UInt8}, p + i)), base = 16, pad = 2))
             end
         end
     end
@@ -552,11 +552,11 @@ end
 
 show(io::IO, ::Nothing) = print(io, "nothing")
 show(io::IO, b::Bool) = print(io, b ? "true" : "false")
-show(io::IO, n::Signed) = (write(io, dec(n)); nothing)
-show(io::IO, n::Unsigned) = print(io, "0x", hex(n,sizeof(n)<<1))
-print(io::IO, n::Unsigned) = print(io, dec(n))
+show(io::IO, n::Signed) = (write(io, string(n)); nothing)
+show(io::IO, n::Unsigned) = print(io, "0x", string(n, pad = sizeof(n)<<1, base = 16))
+print(io::IO, n::Unsigned) = print(io, string(n))
 
-show(io::IO, p::Ptr) = print(io, typeof(p), " @0x$(hex(UInt(p), Sys.WORD_SIZE>>2))")
+show(io::IO, p::Ptr) = print(io, typeof(p), " @0x$(string(UInt(p), base = 16, pad = Sys.WORD_SIZE>>2))")
 
 has_tight_type(p::Pair) =
     typeof(p.first)  == typeof(p).parameters[1] &&

base/stat.jl

@@ -57,7 +57,7 @@ StatStruct(buf::Union{Vector{UInt8},Ptr{UInt8}}) = StatStruct(
     ccall(:jl_stat_ctime,   Float64, (Ptr{UInt8},), buf),
 )
 
-show(io::IO, st::StatStruct) = print(io, "StatStruct(mode=0o$(oct(filemode(st),6)), size=$(filesize(st)))")
+show(io::IO, st::StatStruct) = print(io, "StatStruct(mode=0o$(string(filemode(st), base = 8, pad = 6)), size=$(filesize(st)))")
 
 # stat & lstat functions