NEWS.md

Julia v0.7.0 Release Notes

New language features

• Local variables can be tested for being defined using the new @isdefined variable macro (#22281).

• Destructuring in function arguments: when an expression such as (x, y) is used as a function argument name, the argument is unpacked into local variables x and y as in the assignment (x, y) = arg (#6614).

• Named tuples, with the syntax (a=1, b=2). These behave very similarly to tuples, except components can also be accessed by name using dot syntax t.a (#22194).

• Keyword argument containers (kw in f(; kw...)) are now based on named tuples. Dictionary functions like haskey and indexing can be used on them, and name-value pairs can be iterated using pairs(kw). kw can no longer contain multiple entries for the same argument name (#4916).

• Custom infix operators can now be defined by appending Unicode combining marks, primes, and sub/superscripts to other operators. For example, +̂ₐ″ is parsed as an infix operator with the same precedence as + (#22089).

• The macro call syntax @macroname[args] is now available and is parsed as @macroname([args]) (#23519).

• The construct if @generated ...; else ...; end can be used to provide both @generated and normal implementations of part of a function. Surrounding code will be common to both versions (#23168).

• Added ⟂ (\perp) operator with comparison precedence (#24404).

• The missing singleton object (of type Missing) has been added to represent missing values (#24653). It propagates through standard operators and mathematical functions, and implements three-valued logic, similar to SQLs NULL and R's NA.

• Field access via dot-syntax can now be overloaded by adding methods to Base.getproperty and Base.setproperty! (#1974), optionally along with a corresponding Base.propertynames method for reflection (#25311).

• Values for Enums can now be specified inside of a begin block when using the @enum macro (#25424).

• Keyword arguments can be required: if a default value is omitted, then an exception is thrown if the caller does not assign the keyword a value (#25830).

• The pair operator => is now broadcastable as .=> which was previously a parsing error (#27447)

Language changes

• The syntax for parametric methods, function f{T}(x::T), has been changed to function f(x::T) where {T} (#11310).

• The fallback constructor that calls convert is deprecated. Instead, new types should prefer to define constructors, and add convert methods that call those constructors only as necessary (#15120).

• The syntax 1.+2 is deprecated, since it is ambiguous: it could mean either 1 .+ 2 (the current meaning) or 1. + 2 (#19089).

• Mutable structs with no fields are no longer singletons; it is now possible to make multiple instances of them that can be distinguished by === (#25854). Zero-size immutable structs are still singletons.

• In string and character literals, backslash \ may no longer precede unrecognized escape characters (#22800).

• Juxtaposing binary, octal, and hexadecimal literals is deprecated, since it can lead to confusing code such as 0xapi == 0xa * pi (#16356).

• Numeric literal juxtaposition now has slighty lower precedence than unary operators, so for example √2x parses as (√2) * x (#27641).

• Declaring arguments as x::ANY to avoid specialization has been replaced by @nospecialize x. (#22666).

• Keyword argument default values are now evaluated in successive scopes --- the scope for each expression includes only previous keyword arguments, in left-to-right order (#17240).

• The parsing of 1<<2*3 as 1<<(2*3) is deprecated, and will change to (1<<2)*3 in a future version (#13079).

• The parsing of <| is now right associative. |> remains left associative (#24153).

• : now parses like other operators, as a call to a function named :, instead of calling colon (#25947).

• { } expressions now use braces and bracescat as expression heads instead of cell1d and cell2d, and parse similarly to vect and vcat (#8470).

• Nested if expressions that arise from the keyword elseif now use elseif as their expression head instead of if (#21774).

• let blocks now parse the same as for loops; the first argument is either an assignment or block of assignments, and the second argument is a block of statements (#21774).

• do syntax now parses to an expression with head :do, instead of as a function call (#21774).

• Parsed and lowered forms of type definitions have been synchronized with their new keywords (#23157). Expression heads are renamed as follows:

  • type => struct

  • bitstype => primitive (order of arguments is also reversed, to match syntax)

  • composite_type => struct_type

  • bits_type => primitive_type

• The global keyword now only introduces a new binding if one doesn't already exist in the module. This means that assignment to a global (global sin = 3) may now throw the error: "cannot assign variable Base.sin from module Main", rather than emitting a warning. Additionally, the new bindings are now created before the statement is executed. For example, f() = (global sin = "gluttony"; nothing) will now resolve which module contains sin eagerly, rather than delaying that decision until f is run. (#22984).

• global const declarations may no longer appear inside functions (#12010).

• Uninitialized BitArray constructors of the form BitArray[{N}](shape...) have been deprecated in favor of equivalents accepting undef (an alias for UndefInitializer()) as their first argument, as in BitArray[{N}](undef, shape...). For example, BitVector(3) is now BitVector(undef, 3), BitMatrix((2, 4)) is now BitMatrix(undef, (2, 4)), and BitArray{3}(11, 13, 17) is now BitArray{3}(undef, 11, 14, 17) (#24785).

• Dispatch rules have been simplified: method matching is now determined exclusively by subtyping; the rule that method type parameters must also be captured has been removed. Instead, attempting to access the unconstrained parameters will throw an UndefVarError. Linting in package tests is recommended to confirm that the set of methods which might throw UndefVarError when accessing the static parameters (need_to_handle_undef_sparam = Set{Any}(m.sig for m in Test.detect_unbound_args(Base, recursive=true))) is equal (==) to some known set (expected = Set()). (#23117)

• const declarations on local variables were previously ignored. They now give a warning, so that this syntax can be disallowed or given a new meaning in a future version (#5148).

• Placing an expression after catch, as in catch f(x), is deprecated. Use catch; f(x) instead (#19987).

• In for i = ..., if a local variable i already existed it would be overwritten during the loop. This behavior is deprecated, and in the future for loop variables will always be new variables local to the loop (#22314). The old behavior of overwriting an existing variable is available via for outer i = ....

• In for i in x, x used to be evaluated in a new scope enclosing the for loop. Now it is evaluated in the scope outside the for loop.

• In for i in x, j in y, all variables now have fresh bindings on each iteration of the innermost loop. For example, an assignment to i will not be visible on the next j loop iteration (#330).

• Variable bindings local to while loop bodies are now freshly allocated on each loop iteration, matching the behavior of for loops.

• Prefix & for by-reference arguments to ccall has been deprecated in favor of Ref argument types (#6080).

• The constructor Ref(x::T) now always returns a Ref{T} (#21527).

• All line numbers in ASTs are represented by LineNumberNodes; the :line expression head is no longer used. QuoteNodes are also consistently used for quoted symbols instead of the :quote expression head (though :quote Exprs are still used for quoted expressions) (#23885).

• The + and - methods for Number and UniformScaling are not ambiguous anymore since + and - no longer do automatic broadcasting. Hence, the methods for UniformScaling and Number are no longer deprecated (#23923).

• The keyword importall is deprecated. Use using and/or individual import statements instead (#22789).

• reduce(+, [...]) and reduce(*, [...]) no longer widen the iterated over arguments to system word size. sum and prod still preserve this behavior. (#22825)

• Like _, variable names consisting only of underscores can be assigned, but accessing their values is deprecated (#24221).

• Raw string literal escaping rules have been changed to make it possible to write all strings. The rule is that backslashes escape both quotes and other backslashes, but only when a sequence of backslashes precedes a quote character. Thus, 2n backslashes followed by a quote encodes n backslashes and the end of the literal while 2n+1 backslashes followed by a quote encodes n backslashes followed by a quote character (#22926).

• reprmime(mime, x) has been renamed to repr(mime, x), and along with repr(x) and sprint it now accepts an optional context keyword for IOContext attributes. stringmime has been moved to the Base64 stdlib package (#25990).

• The syntax (x...) for constructing a tuple is deprecated; use (x...,) instead (#24452).

• Non-parenthesized interpolated variables in strings, e.g. "$x", must be followed by a character that will never be an allowed identifier character (currently operators, space/control characters, or common punctuation characters) (#25231).

• The syntax using A.B can now only be used when A.B is a module, and the syntax using A: B can only be used for adding single bindings (#8000).

• => now has its own precedence level, giving it strictly higher precedence than = and , (#25391).

• The conditions under which unary operators followed by ( are parsed as prefix function calls have changed (#26154).

• begin is disallowed inside indexing expressions, in order to enable the syntax a[begin] (for selecting the first element) in the future (#23354).

• Underscores for _italics_ and __bold__ are now supported by the Base Markdown parser. (#25564)

• … (\dots) and ⁝ (\tricolon) are now parsed as binary operators (#26262).

• Assignment syntax (a=b) inside square bracket expressions (e.g. A[...], [x, y]) is deprecated. It will likely be reclaimed in a later version for passing keyword arguments. Note this does not affect updating operators like += (#25631).

• try blocks without catch or finally are no longer allowed. An explicit empty catch block should be written instead (#27554).

• AbstractArray types that use unconventional (not 1-based) indexing can now support size, length, and @inbounds. To optionally enforce conventional indices, you can @assert !has_offset_axes(A).

Breaking changes

This section lists changes that do not have deprecation warnings.

• The package manager Pkg has been replaced with a new one. See the manual entries on "Code Loading" and "Pkg" for documentation.

• replace(s::AbstractString, pat=>repl) for function repl arguments formerly passed a substring to repl in all cases. It now passes substrings for string patterns pat, but a Char for character patterns (when pat is a Char, collection of Char, or a character predicate) (#25815).

• readuntil now does not include the delimiter in its result, matching the behavior of readline. Pass keep=true to get the old behavior (#25633).

• lu methods now return decomposition objects such as LU rather than tuples of arrays or tuples of numbers (#26997, #27159, #27212).

• schur methods now return decomposition objects such as Schur and GeneralizedSchur rather than tuples of arrays (#26997, #27159, #27212).

• lq methods now return decomposition objects such as LQ rather than tuples of arrays (#26997, #27159, #27212).

• qr methods now return decomposition objects such as QR, QRPivoted, and QRCompactWY rather than tuples of arrays (#26997, #27159, #27212).

• svd methods now return decomposition objects such as SVD and GeneralizedSVD rather than tuples of arrays or tuples of numbers (#26997, #27159, #27212).

• countlines now always counts the last non-empty line even if it does not end with EOL, matching the behavior of eachline and readlines (#25845).

• getindex(s::String, r::UnitRange{Int}) now throws StringIndexError if last(r) is not a valid index into s (#22572).

• ntuple(f, n::Integer) throws ArgumentError if n is negative. Previously an empty tuple was returned (#21697).

• ⋮, ⋱, ⋰, and ⋯ are now parsed as binary operators, not ordinary identifiers. ≔, ≕, and ⩴ now parse with assignment rather than comparison precedence (#26262).

• Juxtaposing string literals (e.g. "x"y) is now a syntax error (#20575).

• finalizer(function, object) now returns object rather than nothing (#24679).

• The constructor of SubString now checks if the requested view range is defined by valid indices in the parent AbstractString (#22511).

• Macro calls with for expressions are now parsed as generators inside function argument lists (#18650). Examples:

  • sum(@inbounds a[i] for i = 1:n) used to give a syntax error, but is now parsed as sum(@inbounds(a[i]) for i = 1:n).

  • sum(@m x for i = 1:n end) used to parse the argument to sum as a 2-argument call to macro @m, but now parses it as a generator plus a syntax error for the dangling end.

• @__DIR__ returns the current working directory rather than nothing when not run from a file (#21759).

• @__FILE__ and @__DIR__ return information relative to the file that it was parsed from, rather than from the task-local SOURCE_PATH global when it was expanded.

• All macros receive an extra argument __source__::LineNumberNode which describes the parser location in the source file for the @ of the macro call. It can be accessed as a normal argument variable in the body of the macro. This is implemented by inserting an extra leading argument into the Expr(:macrocall, :@name, LineNumberNode(...), args...) surface syntax. (#21746)

• Passing the same keyword argument multiple times is now a syntax error (#16937).

• getsockname on a TCPSocket now returns the locally bound address and port of the socket. Previously the address of the remote endpoint was being returned (#21825).

• The ~/.juliarc.jl file has been moved to ~/.julia/config/startup.jl and /etc/julia/juliarc.jl file has been renamed to /etc/julia/startup.jl (#26161).

• Using ARGS within startup.jl files or within a .jl file loaded with --load will no longer contain the script name as the first argument. Instead, the script name will be assigned to PROGRAM_FILE. (#22092)

• The format for a ClusterManager specifying the cookie on the command line is now --worker=<cookie>. --worker <cookie> will not work as it is now an optional argument.

• The representation of CartesianRange has changed to a tuple-of-AbstractUnitRanges; the start and stop fields are no longer present. Use first(R) and last(R) to obtain start/stop. (#20974)

• The Diagonal, Bidiagonal, Tridiagonal and SymTridiagonal type definitions have changed from Diagonal{T}, Bidiagonal{T}, Tridiagonal{T} and SymTridiagonal{T} to Diagonal{T,V<:AbstractVector{T}}, Bidiagonal{T,V<:AbstractVector{T}}, Tridiagonal{T,V<:AbstractVector{T}} and SymTridiagonal{T,V<:AbstractVector{T}} respectively (#22718, #22925, #23035, #23154).

• The immediate supertype of BitArray is now simply AbstractArray. BitArray is no longer considered a subtype of DenseArray and StridedArray (#25858).

• When called with an argument that contains NaN elements, findmin and findmax now return the first NaN found and its corresponding index. Previously, NaN elements were ignored. The new behavior matches that of min, max, minimum, and maximum.

• isapprox(x,y) now tests norm(x-y) <= max(atol, rtol*max(norm(x), norm(y))) rather than norm(x-y) <= atol + ..., and rtol defaults to zero if an atol > 0 is specified (#22742).

• Spaces are no longer allowed between @ and the name of a macro in a macro call (#22868).

• Juxtaposition of a non-literal with a macro call (x@macro) is no longer valid syntax (#22868).

• On a cluster, all files are now loaded from the local file system rather than node 1 (#22588). To load the same file everywhere from node 1, one possible alternative is to broadcast a call to include_string: @everywhere include_string(Main, $(read("filename", String)), "filename"). Improving upon this API is left as an opportunity for packages.

• randperm(n) and randcycle(n) now always return a Vector{Int} (independent of the type of n). Use the corresponding mutating functions randperm! and randcycle! to control the array type (#22723).

• Hermitian now ignores any imaginary components in the diagonal instead of checking the diagonal. (#17367)

• Worker-worker connections are setup lazily for an :all_to_all topology. Use keyword arg lazy=false to force all connections to be setup during a addprocs call. (#22814)

• In joinpath(a, b) on Windows, if the drive specifications of a and b do not match, joinpath now returns b instead of throwing an ArgumentError. joinpath(path...) is defined to be left associative, so if any argument has a drive path which does not match the drive of the join of the preceding paths, the prior ones are dropped. (#20912)

• ^(A::AbstractMatrix{<:Integer}, p::Integer) now throws a DomainError if p < 0, unless A == one(A) or A == -one(A) (same as for ^(A::Integer, p::Integer)) (#23366).

• ^(A::AbstractMatrix{<:Integer}, p::Integer) now promotes the element type in the same way as ^(A::Integer, p::Integer). This means, for instance, that [1 1; 0 1]^big(1) will return a Matrix{BigInt} instead of a Matrix{Int} (#23366).

• The element type of the input is now preserved in unique. Previously the element type of the output was shrunk to fit the union of the type of each element in the input. (#22696)

• The promote function now raises an error if its arguments are of different types and if attempting to convert them to a common type fails to change any of their types. This avoids stack overflows in the common case of definitions like f(x, y) = f(promote(x, y)...) (#22801).

• indmin and indmax have been renamed to argmin and argmax, respectively (#25654).

• findmin, findmax, argmin, and argmax used to always return linear indices. They now return CartesianIndexes for all but 1-d arrays, and in general return the keys of indexed collections (e.g. dictionaries) (#22907).

• The openspecfun library is no longer built and shipped with Julia, as it is no longer used internally (#22390).

• All loaded packages used to have bindings in Main (e.g. Main.Package). This is no longer the case; now bindings will only exist for packages brought into scope by typing using Package or import Package (#17997).

• The rules for mixed-signedness integer arithmetic (e.g. Int32(1) + UInt64(1)) have been simplified: if the arguments have different sizes (in bits), then the type of the larger argument is used. If the arguments have the same size, the unsigned type is used (#9292).

• All command line arguments passed via -e, -E, and -L will be executed in the order given on the command line (#23665).

• I now yields UniformScaling{Bool}(true) rather than UniformScaling{Int64}(1) to better preserve types in operations involving I (#24396).

• The return type of reinterpret has changed to ReinterpretArray. reinterpret on sparse arrays has been discontinued.

• Base.find_in_path is now Base.find_package or Base.find_source_file (#24320).

• finalizer now takes functions or pointers as its first argument, and the object being finalized as its second (rather than the reverse). For the majority of use cases deprecation warnings will be triggered. However, deprecation warnings will not trigger where (1) the callable argument is not a subtype of Function; or (2) both arguments are Functions or Ptr{Cvoid}s (#24605).

• The kill function now throws errors on user error (e.g. on permission errors), but returns successfully if the process had previously exited. Its return value has been removed. Use the process_running function to determine if a process has already exited.

• The logging system has been redesigned - info and warn are deprecated and replaced with the logging macros @info, @warn, @debug and @error. The logging function is also deprecated and replaced with AbstractLogger and the functions from the new standard Logging library. (#24490)

• The RevString type has been removed from the language; reverse(::String) returns a String with code points (or fragments thereof) in reverse order. In general, reverse(s) should return a string of the same type and encoding as s with code points in reverse order; any string type overrides reverse to return a different type of string must also override reverseind to compute reversed indices correctly.

• eachindex(A, B...) now requires that all inputs have the same number of elements. When the chosen indexing is Cartesian, they must have the same axes.

• AbstractRange objects are now considered as equal to other AbstractArray objects by == and isequal if all of their elements are equal (#16401). This has required changing the hashing algorithm: ranges now use an O(N) fallback instead of a O(1) specialized method unless they define the Base.RangeStepStyle trait; see its documentation for details. Types which support subtraction (operator -) must now implement widen for hashing to work inside heterogeneous arrays.

• findn(x::AbstractArray) has been deprecated in favor of findall(!iszero, x), which now returns cartesian indices for multidimensional arrays (see below, #25532).

• Broadcasting operations are no longer fused into a single operation by Julia's parser. Instead, a lazy Broadcasted object is created to represent the fused expression and then realized with copy(bc::Broadcasted) or copyto!(dest, bc::Broadcasted) to evaluate the wrapper. Consequently, package authors generally need to specialize copy and copyto! methods rather than broadcast and broadcast!. This also allows for more customization and control of fused broadcasts. See the Interfaces chapter for more information.

• find has been renamed to findall. findall, findfirst, findlast, findnext now take and/or return the same type of indices as keys/pairs for AbstractArray, AbstractDict, AbstractString, Tuple and NamedTuple objects (#24774, #25545). In particular, this means that they use CartesianIndex objects for matrices and higher-dimensional arrays instead of linear indices as was previously the case. Use LinearIndices(a)[findall(f, a)] and similar constructs to compute linear indices.

• The find* functions, i.e. findnext, findprev, findfirst, and findlast, as well as indexin, now return nothing when no match is found rather than 0 or 0:-1 (#25472, #25662, #26149)

• The Base.HasShape iterator trait has gained a type parameter N indicating the number of dimensions, which must correspond to the length of the tuple returned by size (#25655).

• AbstractSet objects are now considered equal by == and isequal if all of their elements are equal (#25368). This has required changing the hashing algorithm for BitSet.

• the default behavior of titlecase is changed in two ways (#23393):

  • characters not starting a word are converted to lowercase; a new keyword argument strict is added which allows to get the old behavior when it's false.
  • any non-letter character is considered as a word separator; to get the old behavior (only "space" characters are considered as word separators), use the keyword wordsep=isspace.

• writedlm in the standard library module DelimitedFiles now writes numeric values using print rather than print_shortest (#25745).

• The tempname function used to create a file on Windows but not on other platforms. It now never creates a file (#9053).

• The fieldnames and propertynames functions now return a tuple rather than an array (#25725).

• indexin now returns the first rather than the last matching index (#25998).

• parse(::Type, ::Char) now uses a default base of 10, like other number parsing methods, instead of 36 (#26576).

• isequal for Ptrs now compares element types; == still compares only addresses (#26858).

• widen on 8- and 16-bit integer types now widens to 16- and 32-bit types, respectively. ([#28045]).

• mv,cp, touch, mkdir, mkpath, chmod and chown now return the path that was created/modified rather than nothing (#27071).

• Regular expressions now default to UCP mode. Escape sequences such as \w will now match based on unicode character properties, e.g. r"\w+" will match café (not just caf). Add the a modifier (e.g. r"\w+"a) to restore the previous behavior (#27189).

• @sync now waits only for lexically enclosed (i.e. visible directly in the source text of its argument) @async expressions. If you need to wait for a task created by a called function f, have f return the task and put @async wait(f(...)) within the @sync block. This change makes @schedule redundant with @async, so @schedule has been deprecated (#27164).

• norm(A::AbstractMatrix, p=2) computes no longer the operator/matrix norm but the norm of A as for other iterables, i.e. as if it were a vector. Especially, norm(A::AbstractMatrix) is the Frobenius norm. To compute the operator/matrix norm, use the new function opnorm (#27401).

• dot(u, v) now acts recursively. Instead of sum(u[i]' * v[i] for i in ...), it computes sum(dot(u[i], v[i]) for i in ...), similarly to vecdot before (#27401).

• Sys.CPU_CORES has been renamed to Sys.CPU_THREADS; it still gives the number of "logical cores" (including hyperthreading) rather than the number of physical cores present on the CPU. Similarly, the environment variable JULIA_CPU_CORES is deprecated in favor of JULIA_CPU_THREADS ([#27856]).

Library improvements

• The function thisind(s::AbstractString, i::Integer) returns the largest valid index less or equal than i in the string s or 0 if no such index exists (#24414).

• Char is now a subtype of AbstractChar, and most of the functions that take character arguments now accept any AbstractChar (#26286).

• bytes2hex now accepts an optional io argument to output to a hexadecimal stream without allocating a String first (#27121).

• String(array) now accepts an arbitrary AbstractVector{UInt8}. For Vector inputs, it "steals" the memory buffer, leaving them with an empty buffer which is guaranteed not to be shared with the String object. For other types of vectors (in particular immutable vectors), a copy is made and the input is not truncated (#26093).

• Irrational is now a subtype of AbstractIrrational (#24245).

• Introduced the empty function, the functional pair to empty! which returns a new, empty container (#24390).

• Jump to first/last history entries in the REPL via "Alt-<" and "Alt->" (#22829).

• REPL LaTeX-like tab completions have been simplified for several Unicode characters, e.g. 𝔸 is now \bbA rather than \BbbA (#25980).

• The function chop now accepts two arguments head and tail allowing to specify number of characters to remove from the head and tail of the string (#24126).

• get(io, :color, false) can now be used to query whether a stream io supports ANSI color codes (#25067), rather than using the undocumented Base.have_color global flag.

• print_with_color has been deprecated in favor of printstyled([io], xs...; bold=false, color=:normal) for printing styled text (#25522).

• Functions first and last now accept nchar argument for AbstractString. If this argument is used they return a string consisting of first/last nchar characters from the original string (#23960).

• Expressions x^-n where n is an integer literal now correspond to inv(x)^n. For example, x^-1 is now essentially a synonym for inv(x), and works in a type-stable way even if typeof(x) != typeof(inv(x)) (#24240).

• New Iterators.reverse(itr) for reverse-order iteration (#24187). Iterator types T can implement start etc. for Iterators.Reverse{T} to support this.

• The functions nextind and prevind now accept nchar argument that indicates the number of characters to move (#23805).

• The functions strip, lstrip and rstrip now return SubString (#22496).

• The functions strwidth and charwidth have been merged into textwidth(#20816).

• The functions base and digits digits now accept a negative base (like ndigits did) (#21692).

• The function randn now accepts complex arguments (Complex{T <: AbstractFloat}) (#21973).

• parse(Complex{T}, string) can parse complex numbers in some common formats (#24713).

• The function rand can now pick up random elements from strings, associatives and sets (#22228, #21960, #18155, #22224).

• Method lists are now printed as a numbered list. In addition, the source code of a method can be opened in an editor by entering the corresponding number in the REPL and pressing ^Q (#22007).

• getpeername on a TCPSocket returns the address and port of the remote endpoint of the TCP connection (#21825).

• resize! and sizehint! methods no longer over-reserve memory when the requested array size is more than double of its current size (#22038).

• The crc32c function for CRC-32c checksums is now exported (#22274).

• eye(::Type{Diagonal{T}}, m::Integer) has been deprecated in favor of Diagonal{T}(I, m) (#24413).

• The output of versioninfo is now controlled with keyword arguments (#21974).

• The function LibGit2.set_remote_url now always sets both the fetch and push URLs for a git repo. Additionally, the argument order was changed to be consistent with the git command line tool (#22062).

• Added unique! which is an inplace version of unique (#20549).

• @test isequal(x, y) and @test isapprox(x, y) now prints an evaluated expression when the test fails (#22296).

• Uses of Val{c} in Base has been replaced with Val{c}(), which is now easily accessible via the efficient constructor Val(c). Functions are defined as f(::Val{c}) = ... and called by f(Val(c)). Notable affected functions include: ntuple, Base.literal_pow, sqrtm, lufact, lufact!, qrfact, qrfact!, cholfact, cholfact!, _broadcast!, reshape, cat and cat_t.

• A new @macroexpand1 macro for non recursive macro expansion (#21662).

• Chars can now be concatenated with Strings and/or other Chars using * (#22532).

• Diagonal, Bidiagonal, Tridiagonal and SymTridiagonal are now parameterized on the type of the wrapped vectors, allowing Diagonal, Bidiagonal, Tridiagonal and SymTridiagonal matrices with arbitrary AbstractVectors (#22718, #22925, #23035, #23154).

• Mutating versions of randperm and randcycle have been added: randperm! and randcycle! (#22723).

• BigFloat random numbers can now be generated (#22720).

• REPL Undo via Ctrl-/ and Ctrl-_

• diagm now accepts several diagonal index/vector Pairs (#24047).

• isequal, ==, and in have one argument "curried" forms. For example isequal(x) returns a function that compares its argument to x using isequal (#26436).

• reinterpret now works on any AbstractArray using the new ReinterpretArray type. This supersedes the old behavior of reinterpret on Arrays. As a result, reinterpreting arrays with different alignment requirements (removed in 0.6) is once again allowed (#23750).

• The keys of an Associative are now an AbstractSet. Base.KeyIterator{<:Associative} has been changed to KeySet{K, <:Associative{K}} <: AbstractSet{K} (#24580).

• New function ncodeunits(s::AbstractString) gives the number of code units in a string. The generic definition is constant time but calls lastindex(s) which may be inefficient. Therefore custom string types may want to define direct ncodeunits methods.

• reverseind(s::AbstractString, i::Integer) now has an efficient generic fallback, so custom string types do not need to provide their own efficient definitions. The generic definition relies on ncodeunits however, so for optimal performance you may need to define a custom method for that function.

• The global RNG is being re-seeded with its own seed at the beginning of each @testset, and have its original state restored at the end (#24445). This is breaking for testsets relying implicitly on the global RNG being in a specific state.

• permutedims(m::AbstractMatrix) is now short for permutedims(m, (2,1)), and is now a more convenient way of making a "shallow transpose" of a 2D array. This is the recommended approach for manipulating arrays of data, rather than the recursively defined, linear-algebra function transpose. Similarly, permutedims(v::AbstractVector) will create a row matrix (#24839).

• A new replace(A, old=>new) function is introduced to replace old by new in collection A. There are also two other methods with a different API, and a mutating variant, replace! (#22324).

• Adding integers to CartesianIndex objects is now deprecated. Instead of i::Int + x::CartesianIndex, use i*one(x) + x (#26284).

• CartesianRange changes (#24715):

  • Inherits from AbstractArray, and linear indexing can be used to provide linear-to-cartesian conversion (#24715)
  • It has a new constructor taking an array

• several missing set-like operations have been added (#23528): union, intersect, symdiff, setdiff are now implemented for all collections with arbitrary many arguments, as well as the mutating counterparts (union! etc.). The performance is also much better in many cases. Note that this change is slightly breaking: all the non-mutating functions always return a new object even if only one argument is passed. Moreover the semantics of intersect and symdiff is changed for vectors:

  • intersect doesn't preserve the multiplicity anymore (use filter for the old behavior)
  • symdiff has been made consistent with the corresponding methods for other containers, by taking the multiplicity of the arguments into account. Use unique to get the old behavior.

• The linearindices function has been deprecated in favor of the new LinearIndices type, which additionally provides conversion from cartesian indices to linear indices using the normal indexing operation. (#24715, #26775).

• IdDict{K,V} replaces ObjectIdDict. It has type parameters like other AbstractDict subtypes and its constructors mirror the ones of Dict. (#25210)

• IOBuffer can take the sizehint keyword argument to suggest a capacity of the buffer (#25944).

• lstrip and rstrip now accept a predicate function that defaults to isspace (#27309).

• trunc, floor, ceil, and round specify digits, sigdigits and base using keyword arguments. (#26156, #26670)

• Sys.which() provides a cross-platform method to find executable files, similar to the Unix which command. (#26559)

• Added an optimized method of vecdot for taking the Frobenius inner product of sparse matrices. (#27470)

• Added an optimized method of kron for taking the tensor product of two Diagonal matrices. ([27581])

• The initial element v0 in reduce(op, v0, itr) has been replaced with an init optional keyword argument, as in reduce(op, itr; init=v0). Similarly for foldl, foldr, mapreduce, mapfoldl, mapfoldr, accumulate and accumulate!. (#27711, #27859)

Compiler/Runtime improvements

• The inlining heuristic now models the approximate runtime cost of a method (using some strongly-simplifying assumptions). Functions are inlined unless their estimated runtime cost substantially exceeds the cost of setting up and issuing a subroutine call. (#22210, #22732)

• Inference recursion-detection heuristics are now more precise, allowing them to be triggered less often, but being more aggressive when they are triggered to drive the inference computation to a solution (#23912).

• Inference now propagates constants inter-procedurally, and can compute various constants expressions at compile-time (#24362).

Deprecated or removed

• The JULIA_HOME environment variable has been renamed to JULIA_BINDIR and Base.JULIA_HOME has been moved to Sys.BINDIR (#20899).

• The keyword immutable is fully deprecated to struct, and type is fully deprecated to mutable struct (#19157, #20418).

• lufact, schurfact, lqfact, qrfact, ldltfact, svdfact, bkfact, hessfact, eigfact, and cholfact have respectively been deprecated to lu, schur, lq, qr, ldlt, svd, bunchkaufman, hessenberg, eigen, and cholesky (#26997, #27159, #27212).

• lufact!, schurfact!, lqfact!, qrfact!, ldltfact!, svdfact!, bkfact!, hessfact!, and eigfact! have respectively been deprecated to lu!, schur!, lq!, qr!, ldlt!, svd!, bunchkaufman!, hessenberg!, and eigen! (#26997, #27159, #27212).

• eig(A[, args...]) has been deprecated in favor of eigen(A[, args...]). Whereas the former returns a tuple of arrays, the latter returns an Eigen object. So for a direct replacement, use (eigen(A[, args...])...,). But going forward, consider using the direct result of eigen(A[, args...]) instead, either destructured into its components (vals, vecs = eigen(A[, args...])) or as an Eigen object (X = eigen(A[, args...])) (#26997, #27159, #27212).

• eig(A::AbstractMatrix, B::AbstractMatrix) and eig(A::Number, B::Number) have been deprecated in favor of eigen(A, B). Whereas the former each return a tuple of arrays, the latter returns a GeneralizedEigen object. So for a direct replacement, use (eigen(A, B)...,). But going forward, consider using the direct result of eigen(A, B) instead, either destructured into its components (vals, vecs = eigen(A, B)), or as a GeneralizedEigen object (X = eigen(A, B)) (#26997, #27159, #27212).

• Indexing into multidimensional arrays with more than one index but fewer indices than there are dimensions is no longer permitted when those trailing dimensions have lengths greater than 1. Instead, reshape the array or add trailing indices so the dimensionality and number of indices match (#14770, #23628).

• The use of a positional dimension argument has largely been deprecated in favor of a dims keyword argument. This includes the functions sum, prod, maximum, minimum, all, any, findmax, findmin, mean, varm, std, var, cov, cor, median, mapreducedim, reducedim, sort, accumulate, accumulate!, cumsum, cumsum!, cumprod, cumprod!, flipdim, squeeze, and cat (#25501, #26660, #27100).

• indices(a) and indices(a,d) have been deprecated in favor of axes(a) and axes(a, d) (#25057).

• EnvHash has been renamed to EnvDict (#24167).

• Uninitialized Array constructors of the form Array[{T,N}](shape...) have been deprecated in favor of equivalents accepting undef (an alias for UndefInitializer()) as their first argument, as in Array[{T,N}](undef, shape...). For example, Vector(3) is now Vector(undef, 3), Matrix{Int}((2, 4)) is now, Matrix{Int}(undef, (2, 4)), and Array{Float32,3}(11, 13, 17) is now Array{Float32,3}(undef, 11, 13, 17) (#24781).

• Previously setindex!(A, x, I...) (and the syntax A[I...] = x) supported two different modes of operation when supplied with a set of non-scalar indices I (e.g., at least one index is an AbstractArray) depending upon the value of x on the right hand side. If x is an AbstractArray, its contents are copied elementwise into the locations in A selected by I and it must have the same number of elements as I selects locations. Otherwise, if x is not an AbstractArray, then its value is implicitly broadcast to all locations to all locations in A selected by I. This latter behavior—implicitly broadcasting "scalar"-like values across many locations—is now deprecated in favor of explicitly using the broadcasted assignment syntax A[I...] .= x or fill!(view(A, I...), x) (#26347).

• broadcast_getindex(A, I...) and broadcast_setindex!(A, v, I...) are deprecated in favor of getindex.((A,), I...) and setindex!.((A,), v, I...), respectively (#27075).

• LinAlg.fillslots! has been renamed LinAlg.fillstored! (#25030).

• fill!(A::Diagonal, x) and fill!(A::AbstractTriangular, x) have been deprecated in favor of Base.LinAlg.fillstored!(A, x) (#24413).

• eye has been deprecated in favor of I and Matrix constructors. Please see the deprecation warnings for replacement details (#24438).

• zeros(D::Diagonal[, opts...]) has been deprecated (#24654).

• Using Bool values directly as indices is now deprecated and will be an error in the future. Convert them to Int before indexing if you intend to access index 1 for true and 0 for false.

• slicedim(A, d, i) has been deprecated in favor of copy(selectdim(A, d, i)). The new selectdim function now always returns a view into A; in many cases the copy is not necessary. Previously, slicedim on a vector V over dimension d=1 and scalar index i would return the just selected element (unless V was a BitVector). This has now been made consistent: selectdim now always returns a view into the original array, with a zero-dimensional view in this specific case (#26009).

• whos has been renamed varinfo, and now returns a markdown table instead of printing output (#12131).

• Uninitialized RowVector constructors of the form RowVector{T}(shape...) have been deprecated in favor of equivalents accepting undef (an alias for UndefInitializer()) as their first argument, as in RowVector{T}(undef, shape...). For example, RowVector{Int}(3) is now RowVector{Int}(undef, 3), and RowVector{Float32}((1, 4)) is now RowVector{Float32}(undef, (1, 4)) (#24786).

• writecsv(io, a; opts...) has been deprecated in favor of writedlm(io, a, ','; opts...) (#23529).

• The method srand(rng, filename, n=4) has been deprecated (#21359).

• readcsv(io[, T::Type]; opts...) has been deprecated in favor of readdlm(io, ','[, T]; opts...) (#23530).

• sparse(s::UniformScaling, m::Integer) has been deprecated in favor of the three-argument equivalent sparse(s::UniformScaling, m, n) (#24472).

• The cholfact/cholfact! methods that accepted an uplo symbol have been deprecated in favor of using Hermitian (or Symmetric) views (#22187, #22188).

• The thin keyword argument for orthogonal decomposition methods has been deprecated in favor of full, which has the opposite meaning: thin == true if and only if full == false (#24279).

• isposdef(A::AbstractMatrix, UL::Symbol) and isposdef!(A::AbstractMatrix, UL::Symbol) have been deprecated in favor of isposdef(Hermitian(A, UL)) and isposdef!(Hermitian(A, UL)) respectively (#22245).

• The bkfact/bkfact! methods that accepted uplo and issymmetric symbols have been deprecated in favor of using Hermitian (or Symmetric) views (#22605).

• The function current_module is deprecated and replaced with @__MODULE__. This caused the deprecation of some reflection methods (such as macroexpand and isconst), which now require a module argument. And it caused the bugfix of other default arguments to use the Main module (including whos, which) (#22064).

• expand(ex) and expand(module, ex) have been deprecated in favor of Meta.lower(module, ex) (#22064, #24278).

• ones(A::AbstractArray[, opts...]) and zeros(A::AbstractArray[, opts...]) methods have been deprecated. For zeros(A), consider zero(A). For ones(A) or zeros(A), consider ones(size(A)), zeros(size(A)), fill(v, size(A)) for v an appropriate one or zero, fill!(copy(A), {1|0}), fill!(similar(A), {1|0}), or any of the preceding with different element type and/or shape depending on opts.... Where strictly necessary, consider fill!(similar(A[, opts...]), {one(eltype(A)) | zero(eltype(A))}). For an algebraic multiplicative identity, consider one(A) (#24656).

• The similar(dims->f(..., dims...), [T], axes...) method to add offset array support to a function f that would otherwise create a non-offset array has been deprecated. Instead, call f(..., axes...) directly and, if needed, the offset array implementation should add offset axis support to the function f directly (#26733).

• The functions ones and zeros used to accept any objects as dimensional arguments, implicitly converting them to Ints. This is now deprecated; only Integers or AbstractUnitRanges are accepted as arguments. Instead, convert the arguments before calling ones or zeros (#26733).

• The variadic size(A, dim1, dim2, dims...) method to return a tuple of multiple dimension lengths of A has been deprecated (#26862).

• The Operators module is deprecated. Instead, import required operators explicitly from Base, e.g. import Base: +, -, *, / (#22251).

• Bindings to the FFTW library have been removed from Base. The DFT framework for building FFT implementations is now in AbstractFFTs.jl, the bindings to the FFTW library are in FFTW.jl, and the Base signal processing functions which used FFTs are now in DSP.jl (#21956).

• The corrected positional argument to cov has been deprecated in favor of a keyword argument with the same name (#21709).

• Omitting spaces around the ? and the : tokens in a ternary expression has been deprecated. Ternaries must now include some amount of whitespace, e.g. x ? a : b rather than x?a:b (#22523 and #22712).

• ? can no longer be used as an identifier name (#22712)

• The method replace(s::AbstractString, pat, r, [count]) is deprecated in favor of replace(s::AbstractString, pat => r; [count]) (#25165). Moreover, count cannot be negative anymore (use typemax(Int) instead (#22325).

• read(io, type, dims) is deprecated to read!(io, Array{type}(undef, dims)) (#21450).

• read(::IO, ::Ref) is now a method of read!, since it mutates its Ref argument (#21592).

• nb_available is now bytesavailable (#25634).

• skipchars(io::IO, predicate; linecomment=nothing) is deprecated in favor of skipchars(predicate, io::IO; linecomment=nothing) (#25667).

• Bidiagonal constructors now use a Symbol (:U or :L) for the upper/lower argument, instead of a Bool or a Char (#22703).

• Bidiagonal, Tridiagonal and SymTridiagonal constructors that automatically converted the input vectors to the same type are deprecated in favor of explicit conversion (#22925, #23035, #23154.

• Calling nfields on a type to find out how many fields its instances have is deprecated. Use fieldcount instead. Use nfields only to get the number of fields in a specific object (#22350).

• fieldnames now operates only on types. To get the names of fields in an object, use fieldnames(typeof(x)) (#22350).

• InexactError, DomainError, and OverflowError now take arguments. InexactError(func::Symbol, type, -3) now prints as "ERROR: InexactError: func(type, -3)", DomainError(val, [msg]) prints as "ERROR: DomainError with val:\nmsg", and OverflowError(msg) prints as "ERROR: OverflowError: msg". (#20005, #22751, #22761)

• The operating system identification functions: is_linux, is_bsd, is_apple, is_unix, and is_windows, have been deprecated in favor of Sys.islinux, Sys.isbsd, Sys.isapple, Sys.isunix, and Sys.iswindows, respectively (#22182).

• The forms of read, readstring, and eachline that accepted both a Cmd object and an input stream are deprecated. Use e.g. read(pipeline(stdin, cmd)) instead (#22762).

• The unexported type AbstractIOBuffer has been renamed to GenericIOBuffer (#17360 #22796).

• IOBuffer(data::AbstractVector{UInt8}, read::Bool, write::Bool, maxsize::Integer), IOBuffer(read::Bool, write::Bool), and IOBuffer(maxsize::Integer) are deprecated in favor of constructors taking keyword arguments (#25872).

• Display has been renamed to AbstractDisplay (#24831).

• Remaining vectorized methods over SparseVectors, particularly floor, ceil, trunc, round, and most common transcendental functions such as exp, log, and sin variants, have been deprecated in favor of dot-syntax (#22961).

• The method String(io::IOBuffer) is deprecated to String(take!(copy(io))) (#21438).

• The function readstring is deprecated in favor of read(io, String) (#22793)

• The function showall is deprecated. Showing entire values is the default, unless an IOContext specifying :limit=>true is in use (#22847).

• issubtype has been deprecated in favor of <: (which used to be an alias for issubtype).

• Calling write on non-isbits arrays is deprecated in favor of explicit loops or serialize (#6466).

• The default startup.jl file on Windows has been removed. Now must explicitly include the full path if you need access to executables or libraries in the Sys.BINDIR directory, e.g. joinpath(Sys.BINDIR, "7z.exe") for 7z.exe (#21540).

• sqrtm has been deprecated in favor of sqrt (#23504).

• expm has been deprecated in favor of exp (#23233).

• logm has been deprecated in favor of log (#23505).

• full has been deprecated in favor of more specific, better defined alternatives. On structured matrices A, consider instead Matrix(A), Array(A), SparseMatrixCSC(A), or sparse(A). On sparse arrays S, consider instead Vector(S), Matrix(S), or Array(S) as appropriate. On factorizations F, consider instead Matrix(F), Array(F), AbstractMatrix(F), or AbstractArray(F). On implicit orthogonal factors Q, consider instead Matrix(Q) or Array(Q); for implicit orthogonal factors that can be recovered in square or truncated form, see the deprecation message for square recovery instructions. On Symmetric, Hermitian, or AbstractTriangular matrices A, consider instead Matrix(S), Array(S), SparseMatrixCSC(S), or sparse(S). On Symmetric matrices A particularly, consider instead LinAlg.copytri!(copy(parent(A)), A.uplo). On Hermitian matrices A particularly, consider instead LinAlg.copytri!(copy(parent(A)), A.uplo, true). On UpperTriangular matrices A particularly, consider instead triu!(copy(parent(A))). On LowerTriangular matrices A particularly, consider instead tril!(copy(parent(A))) (#24250).

• speye has been deprecated in favor of I, sparse, and SparseMatrixCSC constructor methods (#24356).

• Calling union with no arguments is deprecated; construct an empty set with an appropriate element type using Set{T}() instead (#23144).

• Vectorized DateTime, Date, and format methods have been deprecated in favor of dot-syntax (#23207).

• Base.cpad has been removed; use an appropriate combination of rpad and lpad instead (#23187).

• ctranspose and ctranspose! have been deprecated in favor of adjoint and adjoint!, respectively (#23235).

• filter and filter! on dictionaries now pass a single key=>value pair to the argument function, instead of two arguments (#17886).

• rol, rol!, ror, and ror! have been deprecated in favor of specialized methods for circshift/circshift! (#23404).

• Base.SparseArrays.SpDiagIterator has been removed (#23261).

• The function cfunction, has been deprecated in favor of a macro form @cfunction. Most existing uses can be upgraded simply by adding a @. The new syntax now additionally supports allocating closures at runtime, for dealing with C APIs that don't provide a separate void* env-type callback argument. (#26486)

• diagm(v::AbstractVector, k::Integer=0) has been deprecated in favor of diagm(k => v) (#24047).

• diagm(x::Number) has been deprecated in favor of fill(x, 1, 1) (#24047).

• diagm(A::SparseMatrixCSC) has been deprecated in favor of spdiagm(sparsevec(A)) (#23341).

• diagm(A::BitMatrix) has been deprecated, use diagm(0 => vec(A)) or BitMatrix(Diagonal(vec(A))) instead (#23373, #24047).

• ℯ (written as \mscre<TAB> or \euler<TAB>) is now the only (by default) exported name for Euler's number, and the type has changed from Irrational{:e} to Irrational{:ℯ} (#23427).

• The mathematical constants π, pi, ℯ, e, γ, eulergamma, catalan, φ and golden have been moved from Base to a new module; Base.MathConstants. Only π, pi and ℯ are now exported by default from Base (#23427).

• eu (previously an alias for ℯ) has been deprecated in favor of ℯ (or MathConstants.e) (#23427).

• GMP.gmp_version(), GMP.GMP_VERSION, GMP.gmp_bits_per_limb(), and GMP.GMP_BITS_PER_LIMB have been renamed to GMP.version(), GMP.VERSION, GMP.bits_per_limb(), and GMP.BITS_PER_LIMB, respectively. Similarly, MPFR.get_version(), has been renamed to MPFR.version() (#23323). Also, LinAlg.LAPACK.laver() has been renamed to LinAlg.LAPACK.version() and now returns a VersionNumber.

• select, select!, selectperm and selectperm! have been renamed respectively to partialsort, partialsort!, partialsortperm and partialsortperm! (#23051).

• The Range abstract type has been renamed to AbstractRange (#23570).

• map on dictionaries previously operated on key=>value pairs. This behavior is deprecated, and in the future map will operate only on values (#5794).

• map on sets previously returned a Set, possibly changing the order or number of elements. This behavior is deprecated and in the future map will preserve order and number of elements (#26980).

• Previously, broadcast defaulted to treating its arguments as scalars if they were not arrays. This behavior is deprecated, and in the future broadcast will default to iterating over all its arguments. Wrap arguments you wish to be treated as scalars with Ref() or a 1-tuple. Package developers can choose to allow a non-iterable type T to always behave as a scalar by implementing broadcastable(x::T) = Ref(x) (#26212).

• Automatically broadcasted + and - for array + scalar, scalar - array, and so-on have been deprecated due to inconsistency with linear algebra. Use .+ and .- for these operations instead (#22880, #22932).

• flipbits!(B) is deprecated in favor of using in-place broadcast to negate each element: B .= .!B (#27067).

• isleaftype is deprecated in favor of the simpler predicates isconcretetype and isdispatchtuple. Concrete types are those that might equal typeof(x) for some x; isleaftype included some types for which this is not true. Those are now categorized more precisely as "dispatch tuple types" and "!has_free_typevars" (not exported). (#17086, #25496)

• contains(eq, itr, item) is deprecated in favor of any with a predicate (#23716).

• spdiagm(x::AbstractVector) has been deprecated in favor of sparse(Diagonal(x)) alternatively spdiagm(0 => x) (#23757).

• spdiagm(x::AbstractVector, d::Integer) and spdiagm(x::Tuple{<:AbstractVector}, d::Tuple{<:Integer}) have been deprecated in favor of spdiagm(d => x) and spdiagm(d[1] => x[1], d[2] => x[2], ...) respectively. The new spdiagm implementation now always returns a square matrix (#23757).

• spones(A::AbstractSparseArray) has been deprecated in favor of LinAlg.fillstored!(copy(A), 1) (#25037).

• Constructors for LibGit2.UserPasswordCredentials and LibGit2.SSHCredentials which take a prompt_if_incorrect argument are deprecated. Instead, prompting behavior is controlled using the allow_prompt keyword in the LibGit2.CredentialPayload constructor (#23690).

• gradient is deprecated and will be removed in the next release (#23816).

• The timing functions tic, toc, and toq are deprecated in favor of @time and @elapsed (#17046).

• Methods of findfirst, findnext, findlast, and findprev that accept a value to search for are deprecated in favor of passing a predicate (#19186, #10593).

• find functions now operate only on booleans by default. To look for non-zeros, use x->x!=0 or !iszero (#23120).

• The ability of reinterpret to yield Arrays of different type than the underlying storage has been removed. The reinterpret function is still available, but now returns a ReinterpretArray. The three argument form of reinterpret that implicitly reshapes has been deprecated (#23750).

• bits has been deprecated in favor of bitstring (#24281, #24263).

• num2hex and hex2num have been deprecated in favor of reinterpret combined with parse/hex (#22088).

• copy! is deprecated for AbstractSet and AbstractDict, with the intention to re-enable it with a cleaner meaning in a future version (#24844).

• copy! (resp. unsafe_copy!) is deprecated for AbstractArray and is renamed copyto! (resp. unsafe_copyto!); it will be re-introduced with a different meaning in a future version (#24808).

• a:b is deprecated for constructing a StepRange when a and b have physical units (Dates and Times). Use a:s:b, where s = Dates.Day(1) or s = Dates.Second(1).

• trues(A::AbstractArray) and falses(A::AbstractArray) are deprecated in favor of trues(size(A)) and falses(size(A)) respectively (#24595).

• workspace is discontinued, check out Revise.jl for an alternative workflow (#25046).

• cumsum, cumprod, accumulate, their mutating versions, and diff all now require a dim argument instead of defaulting to using the first dimension unless there is only one dimension (#24684, #25457).

• The sum_kbn and cumsum_kbn functions have been moved to the KahanSummation package (#24869).

• isnumber has been renamed to isnumeric (#25021).

• isalpha has been renamed to isletter (#26932).

• is_assigned_char and normalize_string have been renamed to isassigned and normalize, and moved to the new Unicode standard library module. graphemes has also been moved to that module (#25021).

• Sparse array functionality has moved to the SparseArrays standard library module (#25249).

• Linear algebra functionality, and specifically the LinAlg module has moved to the LinearAlgebra standard library module (#25571).

• @printf and @sprintf have been moved to the Printf standard library (#23929,#25056).

• The Libdl module has moved to the Libdl standard library module (#25459).

• The aliases Complex32, Complex64 and Complex128 have been deprecated in favor of ComplexF16, ComplexF32 and ComplexF64 respectively (#24647).

• Base.parentindexes and SharedArrays.localindexes have been renamed to parentindices and localindices, respectively. Similarly, the indexes field in the SubArray type has been renamed to indices without deprecation (#25088).

• Associative has been deprecated in favor of AbstractDict (#25012).

• Void has been renamed back to Nothing with an alias Cvoid for use when calling C with a return type of Cvoid or a return or argument type of Ptr{Cvoid} (#25162).

• Nullable{T} has been deprecated and moved to the Nullables package (#23642). Use Union{T, Nothing} instead, or Union{Some{T}, Nothing} if nothing is a possible value (i.e. Nothing <: T). isnull(x) can be replaced with x === nothing and unsafe_get/get can be dropped or replaced with coalesce. NullException has been removed.

• unshift! and shift! have been renamed to pushfirst! and popfirst! (#23902)

• ipermute! has been deprecated in favor of invpermute! (#25168).

• CartesianRange has been renamed CartesianIndices (#24715).

• sub2ind and ind2sub are deprecated in favor of using CartesianIndices and LinearIndices (#24715).

• getindex(F::Factorization, s::Symbol) (usually seen as e.g. F[:Q]) is deprecated in favor of dot overloading (getproperty) so factors should now be accessed as e.g. F.Q instead of F[:Q] (#25184).

• search and rsearch have been deprecated in favor of findfirst/findnext and findlast/findprev respectively, in combination with curried isequal and in predicates for some methods (#24673).

• search(buf::IOBuffer, delim::UInt8) has been deprecated in favor of either occursin(delim, buf) (to test containment) or readuntil(buf, delim) (to read data up to delim) (#26600).

• ismatch(regex, str) has been deprecated in favor of contains(str, regex) (#24673).

• matchall has been deprecated in favor of collect(m.match for m in eachmatch(r, s)) (#26071).

• similar(::Associative) has been deprecated in favor of empty(::Associative), and similar(::Associative, ::Pair{K, V}) has been deprecated in favour of empty(::Associative, K, V) (#24390).

• findin(a, b) has been deprecated in favor of findall(in(b), a) (#24673).

• module_name has been deprecated in favor of a new, general nameof function. Similarly, the unexported Base.function_name and Base.datatype_name have been deprecated in favor of nameof methods (#25622).

• The module Random.dSFMT is renamed Random.DSFMT (#25567).

• Random.RandomDevice(unlimited::Bool) (on non-Windows systems) is deprecated in favor of Random.RandomDevice(; unlimited=unlimited) (#25668).

• The generic implementations of strides(::AbstractArray) and stride(::AbstractArray, ::Int) have been deprecated. Subtypes of AbstractArray that implement the newly introduced strided array interface should define their own strides method (#25321).

• module_parent, Base.datatype_module, and Base.function_module have been deprecated in favor of parentmodule ([#TODO]).

• rand(t::Tuple{Vararg{Int}}) is deprecated in favor of rand(Float64, t) or rand(t...); rand(::Tuple) will have another meaning in the future (#25429, #25278).

• randjump, which produced an array, is deprecated in favor of the scalar version Future.randjump used with accumulate (#27746).

• The assert function (and @assert macro) have been documented that they are not guaranteed to run under various optimization levels and should therefore not be used to e.g. verify passwords.

• ObjectIdDict has been deprecated in favor of IdDict{Any,Any} (#25210).

• gc and gc_enable have been deprecated in favor of GC.gc and GC.enable (#25616).

• Base.@gc_preserve has been deprecated in favor of GC.@preserve (#25616).

• print_shortest has been discontinued, but is still available in the Base.Grisu submodule (#25745).

• scale! has been deprecated in favor of mul!, lmul!, and rmul! (#25701, #25812).

• The remove_destination keyword argument to cp, mv, and the unexported cptree has been renamed to force (#25979).

• contains has been deprecated in favor of a more general occursin function, which takes its arguments in reverse order from contains (#26283).

• Regex objects are no longer callable. Use occursin instead (#26283).

• The methods of range based on positional arguments have been deprecated in favor of keyword arguments (#25896).

• linspace has been deprecated in favor of range with stop and length keyword arguments (#25896).

• LinSpace has been renamed to LinRange (#25896).

• logspace has been deprecated to its definition (#25896).

• endof(a) has been renamed to lastindex(a), and the end keyword in indexing expressions now lowers to either lastindex(a) (in the case with only one index) or lastindex(a, d) (in cases where there is more than one index and end appears at dimension d) (#23554, #25763).

• DateTime(), Date(), and Time() have been deprecated, instead use DateTime(1), Date(1) and Time(0) respectively (#23724).

• The fallback method ^(x, p::Integer) is deprecated. If your type relied on this definition, add a method such as ^(x::MyType, p::Integer) = Base.power_by_squaring(x, p) (#23332).

• DevNull, STDIN, STDOUT, and STDERR have been renamed to devnull, stdin, stdout, and stderr, respectively (#25786).

• wait and fetch on Task now resemble the interface of Future.

• showcompact(io, x...) has been deprecated in favor of show(IOContext(io, :compact => true), x...) (#26080). Use sprint(show, x..., context=:compact => true) instead of sprint(showcompact, x...).

• isupper, islower, ucfirst and lcfirst have been deprecated in favor of isuppercase, islowercase, uppercasefirst and lowercasefirst, respectively (#26442).

• signif has been deprecated in favor of the sigdigits keyword argument to round.

• Base.IntSet has been deprecated in favor of Base.BitSet (#24282).

• setrounding has been deprecated for Float32 and Float64, as the behaviour was too unreliable (#26935).

• gamma, lgamma, beta, lbeta and lfact have been moved to SpecialFunctions.jl (#27459, #27473).

• atan2 is now a 2-argument method of atan (#27248).

• The functions eigs and svds have been moved to the Arpack.jl package (#27616).

• vecdot and vecnorm are deprecated in favor of dot and norm, respectively (#27401).

• clipboard has been moved to the InteractiveUtils standard library package (along with other utilities mostly used at the interactive prompt, such as edit and less) (#27635).

• ndigits(n, b, [pad]) is deprecated in favor of ndigits(n, base=b, pad=pad) (#27908).

Command-line option changes

• New option --warn-overwrite={yes|no} to control the warning for overwriting method definitions. The default is no (#23002).

• New option --banner={yes,no} allows suppressing or forcing the printing of the startup banner, overriding the default behavior (banner in REPL, no banner otherwise). The --quiet option implies --banner=no even in REPL mode but can be overridden by passing --quiet together with --banner=yes (#23342).

• The option --precompiled has been renamed to --sysimage-native-code (#23054).

• The option --compilecache has been renamed to --compiled-modules (#23054).