Erang/OTP 28.0 Release candidate 2 Released
Henrik Nord X
henrik.x.nord@REDACTED
Wed Mar 19 10:20:22 CET 2025
Inital Release: OTP 28.0
Git Tag: OTP-28.0
Date: 2025-03-19
Trouble Report Id: OTP-16607, OTP-19096, OTP-19115, OTP-19125,
OTP-19127, OTP-19135, OTP-19141, OTP-19144,
OTP-19155, OTP-19156, OTP-19159, OTP-19161,
OTP-19180, OTP-19184, OTP-19194, OTP-19198,
OTP-19204, OTP-19207, OTP-19224, OTP-19226,
OTP-19228, OTP-19230, OTP-19231, OTP-19233,
OTP-19250, OTP-19259, OTP-19262, OTP-19263,
OTP-19271, OTP-19278, OTP-19279, OTP-19285,
OTP-19287, OTP-19290, OTP-19295, OTP-19296,
OTP-19297, OTP-19303, OTP-19306, OTP-19308,
OTP-19313, OTP-19314, OTP-19315, OTP-19317,
OTP-19323, OTP-19324, OTP-19334, OTP-19337,
OTP-19339, OTP-19343, OTP-19345, OTP-19354,
OTP-19355, OTP-19364, OTP-19367, OTP-19369,
OTP-19371, OTP-19376, OTP-19386, OTP-19393,
OTP-19394, OTP-19396, OTP-19398, OTP-19401,
OTP-19403, OTP-19404, OTP-19406, OTP-19413,
OTP-19414, OTP-19419, OTP-19420, OTP-19421,
OTP-19422, OTP-19425, OTP-19426, OTP-19427,
OTP-19430, OTP-19431, OTP-19432, OTP-19441,
OTP-19450, OTP-19451, OTP-19452, OTP-19453,
OTP-19454, OTP-19456, OTP-19460, OTP-19463,
OTP-19465, OTP-19472, OTP-19473, OTP-19474,
OTP-19476, OTP-19477, OTP-19478, OTP-19479,
OTP-19480, OTP-19481, OTP-19483, OTP-19484,
OTP-19485, OTP-19487, OTP-19488, OTP-19492,
OTP-19500, OTP-19502, OTP-19503, OTP-19505,
OTP-19507, OTP-19508, OTP-19509, OTP-19510,
OTP-19512, OTP-19513, OTP-19514, OTP-19515,
OTP-19516, OTP-19517, OTP-19518, OTP-19519,
OTP-19520, OTP-19521, OTP-19522, OTP-19523,
OTP-19524, OTP-19526, OTP-19531, OTP-19532,
OTP-19534, OTP-19535, OTP-19536, OTP-19537,
OTP-19538, OTP-19539, OTP-19540, OTP-19541,
OTP-19544
Seq num: #9388, GH-7819, GH-8037, GH-8099, GH-8113,
GH-8223, GH-8483, GH-8558, GH-8822, GH-8842,
GH-8967, GH-8985, GH-9092, GH-9113, GH-9173,
GH-9255, GH-9279, GH-9366, GH-9413, GH-9438,
GH-9487, OTP-16608, OTP-19545, PR-7830,
PR-7970, PR-8078, PR-8100, PR-8207, PR-8261,
PR-8429, PR-8494, PR-8540, PR-8547, PR-8556,
PR-8573, PR-8589, PR-8590, PR-8592, PR-8600,
PR-8625, PR-8642, PR-8651, PR-8660, PR-8670,
PR-8695, PR-8697, PR-8699, PR-8704, PR-8734,
PR-8772, PR-8792, PR-8793, PR-8798, PR-8805,
PR-8812, PR-8820, PR-8862, PR-8885, PR-8887,
PR-8894, PR-8913, PR-8926, PR-8932, PR-8937,
PR-8938, PR-8943, PR-8945, PR-8960, PR-8962,
PR-8966, PR-8968, PR-8973, PR-8975, PR-8976,
PR-8988, PR-9005, PR-9006, PR-9013, PR-9019,
PR-9020, PR-9042, PR-9045, PR-9079, PR-9082,
PR-9083, PR-9094, PR-9095, PR-9106, PR-9116,
PR-9119, PR-9121, PR-9122, PR-9124, PR-9129,
PR-9141, PR-9149, PR-9154, PR-9171, PR-9186,
PR-9192, PR-9207, PR-9219, PR-9229, PR-9231,
PR-9232, PR-9246, PR-9251, PR-9253, PR-9269,
PR-9271, PR-9272, PR-9275, PR-9276, PR-9277,
PR-9280, PR-9287, PR-9289, PR-9299, PR-9305,
PR-9316, PR-9327, PR-9330, PR-9333, PR-9342,
PR-9344, PR-9363, PR-9376, PR-9396, PR-9398,
PR-9399, PR-9402, PR-9406, PR-9408, PR-9409,
PR-9410, PR-9417, PR-9433, PR-9441, PR-9445,
PR-9446, PR-9448, PR-9468, PR-9472, PR-9478,
PR-9484, PR-9488, PR-9495, PR-9504, PR-9508,
PR-9511, PR-9514, PR-9515, PR-9516, PR-9517,
PR-9518, PR-9519, PR-9538, PR-9563, PR-9579,
PR-9582, PR-9587, PR-9590
System: OTP
Release: 28
Application: asn1-5.3.3, common_test-1.28, compiler-9.0,
crypto-5.6, debugger-6.0, dialyzer-5.4,
diameter-2.5, edoc-1.4, eldap-1.2.15,
erl_interface-5.6, erts-16.0, eunit-2.10,
inets-9.3.3, jinterface-1.15, kernel-10.3,
megaco-4.8, mnesia-4.24, odbc-2.16,
os_mon-2.11, parsetools-2.7, public_key-1.18,
runtime_tools-2.2, sasl-4.3, snmp-5.19,
ssh-5.3, ssl-11.3, stdlib-7.0,
syntax_tools-4.0, tools-4.1.2, wx-2.5,
xmerl-2.1.2
Predecessor: OTP
Check out the git tag OTP-28.0, and build a full OTP system including
documentation.
# HIGHLIGHTS
- For various error types, the compiler now tries to suggest potential
fixes by
adding "did you mean ...?" at the end of error messages.
When a function is used with wrong arity, the compiler will try to
suggest a
defined function with the same name but a different arity. For
example, given
the following module:
-module(typos).
-export([t/0]).
bar(A) -> A.
bar(A,A,A) -> A.
bar(A,A,A,A) -> A.
t() -> bar(0, 0).
The compiler will emit the following message:
typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4?
% 6| t() -> bar(0, 0).
% | ^
For compiler errors that can easily be caused by typos, the compiler
will try
to suggest what the correct variable or function name, could be. For
example,
given the following module:
-module(typos).
-export([bar/2]).
bar(A0, B0) ->
A + B.
the compiler will emit the following error messages:
typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'?
% 5| A + B.
% | ^
typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'?
% 5| A + B.
% | ^
Error types that now suggest correct arities: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `bad_nowarn_bif_clash`,
`undefined_function`.
Error types that now suggest correct names: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `undefined_on_load`,
`undefined_function`,
`undefined_record`, `undefined_field`, `unbound_var`.
Using a function with wrong arity has higher precedence than having a
typo in
the function name. If the compiler can find a defined function with
the same
name but a different arity, it will not suggest a defined function
with a
close-enough name, regardless of arity.
Own Id: OTP-19180
Application(s): compiler, stdlib
Related Id(s): PR-8699, PR-9094
- Comprehensions have been extended with zip generators according to
EEP 73.
Example:
1> [A+B || A <- [1,2,3] && B <- [4,5,6]].
[5,7,9]
Own Id: OTP-19184
Application(s): compiler, debugger, stdlib, syntax_tools
Related Id(s): PR-8926
- Functionality making it possible for processes to enable reception of
priority messages has been introduced in accordance with EEP 76.
Own Id: OTP-19198
Application(s): erts
Related Id(s): PR-9269, PR-9519, PR-9590
- The `erl -noshell` mode has been updated to have two sub modes called
`raw`
and `cooked`, where `cooked` is the old default behaviour and `raw`
can be
used to bypass the line-editing support of the native terminal. Using
`raw`
mode it is possible to read keystrokes as they happen without the
user having
to press Enter. Also, the `raw` mode does not echo the typed
characters to
stdout. An example of how to create a tic-tac-toe game using this
mechanism is
included in the documentation.
Own Id: OTP-19314
Application(s): erts, stdlib
Related Id(s): GH-8037, PR-8962
- New strict generators have been added for comprehensions.
The currently existing generators are "relaxed": they ignore terms in
the
right-hand side expression that do not match the left-hand side
pattern.
The new strict generators fail with exception `badmatch` if a pattern
doesn't
match.
Examples:
Using the current relaxed generator operator `<-`, any element not
matching
the pattern `{_,_}` will be silently discarded:
1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]].
[{ok,1},{error,2}]
If the intention is that all lists processed by a list comprehension
must only
contain tuples of size two, using the new strict version of the
operator
ensures that term not matching will cause a crash:
2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]].
** exception error: no match of right hand side value ok
Using the strict generator operator to mark the intention that all
list
elements must match the pattern could help finding mistakes quicker
if
something unpexected is added to the list processed by the generator.
The strict version for bitstring generators is `<:=`.
Own Id: OTP-19317
Application(s): compiler, debugger, stdlib, syntax_tools
Related Id(s): PR-8625
- The `join(Binaries, Separator)` function that joins a list of
binaries has
been added to the `binary` module.
Own Id: OTP-19337
Application(s): stdlib
Related Id(s): GH-8099, PR-8100
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Application(s): dialyzer, diameter, edoc, erts, eunit, kernel,
mnesia,
parsetools, runtime_tools, snmp
Related Id(s): PR-9079
- Module `re` has been updated to use PCRE2, which is mostly backward
compatible with PCRE.
The most noticeable incompatibilities are
- The default character encoding is pure ASCII and not Latin1.
Unicode support
is still available with options `unicode` and `ucp`.
- Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set
when a
regex is compiled and cannot be changed at matching for precompiled
regex.
Own Id: OTP-19431
Application(s): erts, stdlib
Related Id(s): PR-9299
*** POTENTIAL INCOMPATIBILITY ***
- It is now possible to use any base for floating point numbers as
described in
EEP 75: Based Floating Point Literals.
Computers represent floating point numbers in binary, but such
numbers are
typically printed using base ten, for example 0.314159265e1. To
maintain exact
bit-level precision when converting numbers to and from text, it is
better to
use a base that matches the internally used base, such as 16 for a
compact but
still exact representation, or 2 for visualizing or writing down the
exact
internal format. One particular case where such exact representations
are
useful is in code generating tools.
Examples:
> 2#0.111.
0.875
> 16#fefe.fefe#e16.
1.2041849337671418e24
Own Id: OTP-19452
Application(s): otp, stdlib
Related Id(s): PR-9106
- There is a new `zstd` module that does Zstandard compression.
Own Id: OTP-19477
Application(s): stdlib
Related Id(s): PR-9316
- The compiler’s alias analysis pass is now both faster and less
conservative,
allowing optimizations of records and binary construction to be
applied in
more cases.
Own Id: OTP-19502
Application(s): compiler
Related Id(s): PR-8695
- Line numbers used to be reported in the following way:
1> lists:last([]).
** exception error: no function clause matching lists:last([])
(lists.erl, line 389)
Starting from Erlang/OTP 28, line numbers are now reported in the
following
way:
1> lists:last([]).
** exception error: no function clause matching lists:last([])
(lists.erl:389)
Own Id: OTP-19538
Application(s): stdlib
Related Id(s): PR-9468
# POTENTIAL INCOMPATIBILITIES
- `proc_lib:stop/1,3` (and in extension gen_server:stop/3,
gen_statem:stop/3
and so on) have been updated to not throw an error if the process to
be
stopped exits with the same reason as given to proc_lib:stop/3.
Own Id: OTP-19233
Application(s): stdlib
Related Id(s): PR-8772
- The size of an atom in the Erlang source code was limited to 255
bytes in
previous releases, meaning that an atom containing only emojis could
contain
only 63 emojis.
While atoms are still only allowed to contain 255 characters, the
number of
bytes is no longer limited.
External tools that parse the `AtU8` chunk of a BEAM file directly
need to be
updated. Tools that use
`beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom
table
will continue to work.
Own Id: OTP-19285
Application(s): compiler, erts, stdlib
Related Id(s): PR-8913
- The `undec_rest` option would be ignored in generated functions for
exclusive
decode. The option is now respected, meaning that the return value
from such
functions are now three-tuples instead of a two-tuples.
Own Id: OTP-19290
Application(s): asn1
Related Id(s): PR-8798
- The literals chunk in BEAM is no longer compressed, resulting in
slightly
smaller BEAM files when a BEAM file is stripped using
beam_lib:strip_files/1.
This is a potential incompatibility for tools that read and interpret
the
contents of the literal chunk. One way to update such tools to work
with the
new format is to retrieve the chunk using
`beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2).
Own Id: OTP-19323
Application(s): compiler, erts, stdlib
Related Id(s): GH-8967, PR-8988
- The `abort_if_missing_suites` option now defaults to `true`. If you
prefer the
old behavior, set `abort_if_missing_suites` to `false` in your test
runs.
Own Id: OTP-19355
Application(s): common_test
Related Id(s): PR-9045
- CBC algorithms are not offered by default. See Configuring algorithms
in SSH
if you wish to enable them.
Own Id: OTP-19420
Application(s): ssh
Related Id(s): PR-9277
- Module `re` has been updated to use PCRE2, which is mostly backward
compatible with PCRE.
The most noticeable incompatibilities are
- The default character encoding is pure ASCII and not Latin1.
Unicode support
is still available with options `unicode` and `ucp`.
- Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set
when a
regex is compiled and cannot be changed at matching for precompiled
regex.
Own Id: OTP-19431
Application(s): erts, stdlib
Related Id(s): PR-9299
*** HIGHLIGHT ***
- If a process being suspended using `erlang:suspend_process()`
currently is
waiting in a `receive ... after` expression, the timer for the
timeout will
now also be suspended until the process is resumed.
Own Id: OTP-19536
Application(s): erts
Related Id(s): PR-8670
# OTP-28.0
## Improvements and New Features
- It is now possible to use any base for floating point numbers as
described in
EEP 75: Based Floating Point Literals.
Computers represent floating point numbers in binary, but such
numbers are
typically printed using base ten, for example 0.314159265e1. To
maintain exact
bit-level precision when converting numbers to and from text, it is
better to
use a base that matches the internally used base, such as 16 for a
compact but
still exact representation, or 2 for visualizing or writing down the
exact
internal format. One particular case where such exact representations
are
useful is in code generating tools.
Examples:
> 2#0.111.
0.875
> 16#fefe.fefe#e16.
1.2041849337671418e24
Own Id: OTP-19452
Related Id(s): PR-9106
*** HIGHLIGHT ***
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
- Fixes the sarif generation in the scan code script
Own Id: OTP-19492
Related Id(s): PR-9409
# asn1-5.3.3
## Fixed Bugs and Malfunctions
- The `undec_rest` option would be ignored in generated functions for
exclusive
decode. The option is now respected, meaning that the return value
from such
functions are now three-tuples instead of a two-tuples.
Own Id: OTP-19290
Related Id(s): PR-8798
*** POTENTIAL INCOMPATIBILITY ***
> #### Full runtime dependencies of asn1-5.3.3
>
> erts-14.0, kernel-9.0, stdlib-5.0
# common_test-1.28
## Fixed Bugs and Malfunctions
- Replaced calls to deprecated `crypto:start()` with
`application:start(crypto)`.
Own Id: OTP-19485
Related Id(s): PR-8592
## Improvements and New Features
- The overage reports in HTML can be rendered in dark mode if requested
by the
user's browser.
Own Id: OTP-19159
Related Id(s): PR-7830
- The `abort_if_missing_suites` option now defaults to `true`. If you
prefer the
old behavior, set `abort_if_missing_suites` to `false` in your test
runs.
Own Id: OTP-19355
Related Id(s): PR-9045
*** POTENTIAL INCOMPATIBILITY ***
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
> #### Full runtime dependencies of common_test-1.28
>
> compiler-6.0, crypto-4.5, debugger-4.1, erts-7.0, ftp-1.0, inets-6.0,
> kernel-8.4, observer-2.1, runtime_tools-1.8.16, sasl-2.5, snmp-5.1.2,
ssh-4.0,
> stdlib-4.0, syntax_tools-1.7, tools-3.2, xmerl-1.3.8
# compiler-9.0
## Fixed Bugs and Malfunctions
- The compiler will now emit warnings when some map patterns cannot
possibly
match because a previous clauses matches the same pattern. For
example:
mm_1(#{}) -> a;
mm_1(#{b := B}) -> {b,B}.
mm_2(#{a := A}) -> {a,A};
mm_2(#{a := A, b := B}) -> {b,A,B}.
The second clause of these function can never match and the compiler
will now
emit a warning for both of them.
Note that the compiler is not guaranteed to emit warnings for every
possible
map pattern that cannot match.
Own Id: OTP-19141
Related Id(s): GH-8558, PR-8600
- The size of an atom in the Erlang source code was limited to 255
bytes in
previous releases, meaning that an atom containing only emojis could
contain
only 63 emojis.
While atoms are still only allowed to contain 255 characters, the
number of
bytes is no longer limited.
External tools that parse the `AtU8` chunk of a BEAM file directly
need to be
updated. Tools that use
`beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom
table
will continue to work.
Own Id: OTP-19285
Related Id(s): PR-8913
*** POTENTIAL INCOMPATIBILITY ***
- The literals chunk in BEAM is no longer compressed, resulting in
slightly
smaller BEAM files when a BEAM file is stripped using
beam_lib:strip_files/1.
This is a potential incompatibility for tools that read and interpret
the
contents of the literal chunk. One way to update such tools to work
with the
new format is to retrieve the chunk using
`beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2).
Own Id: OTP-19323
Related Id(s): GH-8967, PR-8988
*** POTENTIAL INCOMPATIBILITY ***
- The final validation step in the compiler will now reject modules
containing
functions with more than 255 arguments. No impact is expected as the
emulator
has always refused to load these modules.
Own Id: OTP-19376
Related Id(s): GH-9113, PR-9121
- Replaced calls to deprecated `crypto:start()` with
`application:start(crypto)`.
Own Id: OTP-19485
Related Id(s): PR-8592
## Improvements and New Features
- The EEP-48 doc chunk embedded into `.beam` files by the compiler is
now
`compressed` and `deterministic`.
Own Id: OTP-19096
Related Id(s): PR-8494
- Provided that the map argument for a maps:put/3 call is known to the
compiler to be a map, the compiler will replace such calls with the
corresponding update using the map syntax.
Own Id: OTP-19115
Related Id(s): PR-8540
- For various error types, the compiler now tries to suggest potential
fixes by
adding "did you mean ...?" at the end of error messages.
When a function is used with wrong arity, the compiler will try to
suggest a
defined function with the same name but a different arity. For
example, given
the following module:
-module(typos).
-export([t/0]).
bar(A) -> A.
bar(A,A,A) -> A.
bar(A,A,A,A) -> A.
t() -> bar(0, 0).
The compiler will emit the following message:
typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4?
% 6| t() -> bar(0, 0).
% | ^
For compiler errors that can easily be caused by typos, the compiler
will try
to suggest what the correct variable or function name, could be. For
example,
given the following module:
-module(typos).
-export([bar/2]).
bar(A0, B0) ->
A + B.
the compiler will emit the following error messages:
typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'?
% 5| A + B.
% | ^
typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'?
% 5| A + B.
% | ^
Error types that now suggest correct arities: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `bad_nowarn_bif_clash`,
`undefined_function`.
Error types that now suggest correct names: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `undefined_on_load`,
`undefined_function`,
`undefined_record`, `undefined_field`, `unbound_var`.
Using a function with wrong arity has higher precedence than having a
typo in
the function name. If the compiler can find a defined function with
the same
name but a different arity, it will not suggest a defined function
with a
close-enough name, regardless of arity.
Own Id: OTP-19180
Related Id(s): PR-8699, PR-9094
*** HIGHLIGHT ***
- Comprehensions have been extended with zip generators according to
EEP 73.
Example:
1> [A+B || A <- [1,2,3] && B <- [4,5,6]].
[5,7,9]
Own Id: OTP-19184
Related Id(s): PR-8926
*** HIGHLIGHT ***
- Documentation chunks (EEP-48) has been updated to include the
following
reserved metadata fields: `behaviours`, `group`, `source_path`, and
`source_annos`. The compiler has also been updated to emit this
metadata. See
the EEP-48 documentation for more details.
Own Id: OTP-19306
Related Id(s): PR-8945, PR-8975
- New strict generators have been added for comprehensions.
The currently existing generators are "relaxed": they ignore terms in
the
right-hand side expression that do not match the left-hand side
pattern.
The new strict generators fail with exception `badmatch` if a pattern
doesn't
match.
Examples:
Using the current relaxed generator operator `<-`, any element not
matching
the pattern `{_,_}` will be silently discarded:
1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]].
[{ok,1},{error,2}]
If the intention is that all lists processed by a list comprehension
must only
contain tuples of size two, using the new strict version of the
operator
ensures that term not matching will cause a crash:
2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]].
** exception error: no match of right hand side value ok
Using the strict generator operator to mark the intention that all
list
elements must match the pattern could help finding mistakes quicker
if
something unpexected is added to the list processed by the generator.
The strict version for bitstring generators is `<:=`.
Own Id: OTP-19317
Related Id(s): PR-8625
*** HIGHLIGHT ***
- New options for suppressing behaviour warnings have been added:
- `nowarn_conflicting_behaviours`
- `nowarn_undefined_behaviour_func`
- `nowarn_undefined_behaviour`
- `nowarn_undefined_behaviour_callbacks`
- `nowarn_ill_defined_behaviour_callbacks`
- `nowarn_ill_defined_optional_callbacks`
Own Id: OTP-19334
Related Id(s): GH-8985, PR-9020
- Some BIFs with side-effects are optimized in `try`/`catch` in the
same way as
guard BIFs in order to gain performance.
The following BIFs that are optimized in this way:
`binary_to_atom/1`,
`binary_to_atom/2`, `binary_to_existing_atom/1`, `list_to_atom/1`,
and
`list_to_existing_atom/1`.
Own Id: OTP-19339
Related Id(s): PR-9042, PR-9122
- The compiler now converts known documentation attribute metadata
entries from
unicode:chardata/0 to unicode:unicode_binary/0.
Own Id: OTP-19394
Related Id(s): PR-9192
- The `warn_deprecated_catch` option enables warnings for use of old-
style catch
expressions on the form `catch Expr` instead of the modern
`try ... catch ... end`. To prevent new uses of uses of old catches
to be
added, this compiler option can be enabled on the project level and
`-compile(nowarn_deprecated_catch).` added to individual files that
still
contain old catches.
Own Id: OTP-19425
Related Id(s): PR-9154
- Defining a fun in terms of an imported function is not allowed.
Before this
release, the compiler would not catch this kind of error if the name
of the
imported function happened to be a BIF. Consider this example:
-module(fun_example).
-export([foo/0, bar/0]).
-import(m, [max/2, not_a_bif/0]).
foo() ->
fun max/2.
bar() ->
fun not_a_bif/0.
The compiler in Erlang/OTP 27 would generate the following messages:
fun_example.erl:9:5: function not_a_bif/0 undefined
% 9| fun not_a_bif/0.
% | ^
fun_example.erl:3:2: Warning: import directive overrides auto-
imported BIF max/2 --
use "-compile({no_auto_import,[max/2]})." to resolve name clash
% 3| -import(m, [max/2, not_a_bif/0]).
% | ^
That is, there would be a (cryptic) error for `fun not_a_bif/0`, but
only a
warning for `fun max/2`.
When compiling with this release, both attempts to create a fun will
result in
error messages (as well as a warning):
fun_example.erl:6:5: creating a fun from imported name max/2 is
not allowed
% 6| fun max/2.
% | ^
fun_example.erl:9:5: creating a fun from imported name
not_a_bif/0 is not allowed
% 9| fun not_a_bif/0.
% | ^
fun_example.erl:3:2: Warning: import directive overrides auto-
imported BIF max/2 --
use "-compile({no_auto_import,[max/2]})." to resolve name clash
% 3| -import(m, [max/2, not_a_bif/0]).
% | ^
Also, attempting to call a local function having the same name as
auto-imported BIF would result in an error if the BIF was added to
Erlang/OTP
before R14, and a warning for newer BIFs. This has been changed to
always emit
a warning. For example:
-module(bif_example).
-export([bar/1]).
bar(B) ->
is_boolean(B).
is_boolean(B) ->
B =:= true orelse B =:= false.
will now result in the following warning instead of an error:
if_example.erl:5:5: Warning: ambiguous call of overridden auto-
imported BIF is_boolean/1 --
use erlang:is_boolean/1 or "-
compile({no_auto_import,[is_boolean/1]})." to resolve name clash
% 5| is_boolean(B).
% | ^
Own Id: OTP-19432
Related Id(s): PR-9246
- The compiler’s alias analysis pass is now both faster and less
conservative,
allowing optimizations of records and binary construction to be
applied in
more cases.
Own Id: OTP-19502
Related Id(s): PR-8695
*** HIGHLIGHT ***
- BEAM files no longer include a `Meta` chunk if there are no features
used.
That slightly decreases the size of BEAM files, and it also ensures
that
`m(Module)` and `beam_lib:md5(Beam)` will match for preloaded
modules.
Own Id: OTP-19524
Related Id(s): PR-9517
> #### Full runtime dependencies of compiler-9.0
>
> crypto-5.1, erts-13.0, kernel-8.4, stdlib-6.0
# crypto-5.6
## Fixed Bugs and Malfunctions
- Fixed minor potential leak of EVP_MAC when `crypto` module is
unloaded.
Own Id: OTP-19500
Related Id(s): PR-9119
## Improvements and New Features
- The crypto:start/0, crypto:stop/0, and crypto:enable_fips_mode/1
functions have been deprecated.
Own Id: OTP-19155
Related Id(s): PR-8592
- Warnings are now logged if module `crypto` with FIPS-supported
OpenSSL is
loaded without application `crypto` being loaded. In this case FIPS
will be
disabled even if the user had set application parameter `fips_mode`.
Own Id: OTP-19156
Related Id(s): PR-8590
- The functionality of crypto:crypto_one_time_aead/6 is now also
available in
the new functions crypto:crypto_one_time_aead_init/4 and
crypto:crypto_one_time_aead/4, which makes it possible to reuse
initialization.
Own Id: OTP-19426
Related Id(s): PR-9289
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- New key `fips_provider_buildinfo` in map returned by crypto:info/0.
If
present, it contains the version of the FIPS provider which may be
different
than the version of the rest of OpenSSL.
Own Id: OTP-19487
Related Id(s): GH-9366, PR-9410
- Exported `crypto` types `sha3()`, `hmac_hash_algorithm()` and
`cmac_cipher_algorithm()`.
Own Id: OTP-19510
Related Id(s): PR-9448
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of crypto-5.6
>
> erts-9.0, kernel-6.0, stdlib-3.9
# debugger-6.0
## Fixed Bugs and Malfunctions
- Error handling has been improved when modules fail to load.
Own Id: OTP-19484
Related Id(s): GH-7819, PR-9399
## Improvements and New Features
- Comprehensions have been extended with zip generators according to
EEP 73.
Example:
1> [A+B || A <- [1,2,3] && B <- [4,5,6]].
[5,7,9]
Own Id: OTP-19184
Related Id(s): PR-8926
*** HIGHLIGHT ***
- New strict generators have been added for comprehensions.
The currently existing generators are "relaxed": they ignore terms in
the
right-hand side expression that do not match the left-hand side
pattern.
The new strict generators fail with exception `badmatch` if a pattern
doesn't
match.
Examples:
Using the current relaxed generator operator `<-`, any element not
matching
the pattern `{_,_}` will be silently discarded:
1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]].
[{ok,1},{error,2}]
If the intention is that all lists processed by a list comprehension
must only
contain tuples of size two, using the new strict version of the
operator
ensures that term not matching will cause a crash:
2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]].
** exception error: no match of right hand side value ok
Using the strict generator operator to mark the intention that all
list
elements must match the pattern could help finding mistakes quicker
if
something unpexected is added to the list processed by the generator.
The strict version for bitstring generators is `<:=`.
Own Id: OTP-19317
Related Id(s): PR-8625
*** HIGHLIGHT ***
> #### Full runtime dependencies of debugger-6.0
>
> compiler-8.0, erts-15.0, kernel-10.0, stdlib-7.0, wx-2.0
# dialyzer-5.4
## Fixed Bugs and Malfunctions
- The `-Wno_unknown` option will now prevent a warning being printed to
standard
output when the command line interface is used.
Own Id: OTP-19262
Related Id(s): GH-8822, PR-8885
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
> #### Full runtime dependencies of dialyzer-5.4
>
> compiler-8.0, erts-12.0, kernel-8.0, stdlib-5.0, syntax_tools-2.0
# diameter-2.5
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
> #### Full runtime dependencies of diameter-2.5
>
> erts-10.0, kernel-3.2, ssl-9.0, stdlib-5.0
# edoc-1.4
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
> #### Full runtime dependencies of edoc-1.4
>
> erts-11.0, inets-5.10, kernel-7.0, stdlib-4.0, syntax_tools-2.0,
xmerl-1.3.7
# eldap-1.2.15
## Improvements and New Features
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
> #### Full runtime dependencies of eldap-1.2.15
>
> asn1-3.0, erts-6.0, kernel-3.0, ssl-5.3.4, stdlib-3.4
# erl_interface-5.6
## Improvements and New Features
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
## Known Bugs and Problems
- The `ei` API for decoding/encoding terms is not fully 64-bit
compatible since
terms that have a representation on the external term format larger
than 2 GB
cannot be handled.
Own Id: OTP-16607
Related Id(s): OTP-16608
# erts-16.0
## Fixed Bugs and Malfunctions
- ETS tables with more than 2 billion keys are now supported.
Own Id: OTP-19144
Related Id(s): PR-8589
- The zlib library included in Erlang/OTP has been updated to version
1.3.1.
Own Id: OTP-19259
Related Id(s): PR-8862
- `to_erl` no longer clears the screen when attaching to a `run_erl`
session.
Own Id: OTP-19263
Related Id(s): PR-8943
- The size of an atom in the Erlang source code was limited to 255
bytes in
previous releases, meaning that an atom containing only emojis could
contain
only 63 emojis.
While atoms are still only allowed to contain 255 characters, the
number of
bytes is no longer limited.
External tools that parse the `AtU8` chunk of a BEAM file directly
need to be
updated. Tools that use
`beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom
table
will continue to work.
Own Id: OTP-19285
Related Id(s): PR-8913
*** POTENTIAL INCOMPATIBILITY ***
- Fixed a bug where `erlc` would crash if its path contained spaces.
Own Id: OTP-19295
Related Id(s): PR-8937
- The `-noshell` mode has been updated to read data lazily from
standard
input. Before this fix any data would be read greedily which meant
that Erlang
could consume data not meant for it. It also meant that in order for
shell:start_interactive/0 to work on Windows an API that did not
support
reading of Unicode characters had to be used.
Own Id: OTP-19313
Related Id(s): GH-8113, PR-8962
- The literals chunk in BEAM is no longer compressed, resulting in
slightly
smaller BEAM files when a BEAM file is stripped using
beam_lib:strip_files/1.
This is a potential incompatibility for tools that read and interpret
the
contents of the literal chunk. One way to update such tools to work
with the
new format is to retrieve the chunk using
`beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2).
Own Id: OTP-19323
Related Id(s): GH-8967, PR-8988
*** POTENTIAL INCOMPATIBILITY ***
- Fixed erlang:localtime_to_universaltime/2 with `IsDST` set to `true`
and a
timezone without daylight saving (for example `UTC`) to assume that
the
provided localtime does not have DST. This has always been the
behaviour, but
glibc versions after 2.37 changed it so that the behavior in Erlang
also
changed.
Own Id: OTP-19453
Related Id(s): PR-9207
- Support for the `TZ` environment variable has been added on Windows.
Before
this change only the time zone configured in the OS was ever used.
Own Id: OTP-19454
Related Id(s): PR-9207
- Suppressed various warnings when building the emulator with recent
versions of
GCC
Own Id: OTP-19488
Related Id(s): GH-9413, PR-9417
- Fixed a bug in re:run and re:compile where the pattern parameter
would be read
incorrectly if it was a sub-binary.
Own Id: OTP-19507
Related Id(s): GH-9438, PR-9478
- Fixed a broken makefile rule that made it so that `O2` and `-O2`
could not be
part of the directory path when building Erlang/OTP. Bug has been
present
since R11B released 2006.
Own Id: OTP-19518
Related Id(s): GH-9487, PR-9488
- Fixed the index types of modules `atomics` and `counters` from
`integer()` to
`pos_integer()`, which is more correct.
Own Id: OTP-19532
Related Id(s): PR-9538
## Improvements and New Features
- Functionality making it possible for processes to enable reception of
priority messages has been introduced in accordance with EEP 76.
Own Id: OTP-19198
Related Id(s): PR-9269, PR-9519, PR-9590
*** HIGHLIGHT ***
- The trace:system/3 function has been added. It has a similar
interface as
erlang:system_monitor/2 but it also supports trace sessions.
Own Id: OTP-19271
Related Id(s): PR-8660
- Added support for `SIGWINCH`, `SIGCONT`, and `SIGINFO` signals to
os:set_signal/2 where available.
Own Id: OTP-19278
Related Id(s): PR-8887, PR-8938
- The `erl -noshell` mode has been updated to have two sub modes called
`raw`
and `cooked`, where `cooked` is the old default behaviour and `raw`
can be
used to bypass the line-editing support of the native terminal. Using
`raw`
mode it is possible to read keystrokes as they happen without the
user having
to press Enter. Also, the `raw` mode does not echo the typed
characters to
stdout. An example of how to create a tic-tac-toe game using this
mechanism is
included in the documentation.
Own Id: OTP-19314
Related Id(s): GH-8037, PR-8962
*** HIGHLIGHT ***
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- Two BIFs have been added to the `erlang` module.
erlang:processes_iterator/0 returns a process iterator that can be
used to
iterate through the process table.
erlang:process_next/1 takes in a process iterator and returns a 2-
tuple,
consisting of a process identifier and a new process iterator. When
the
process iterator runs out of processes in the process table, `none`
will be
returned.
Using these BIFs to scan the processes scales better than using
erlang:processes/0, at the cost of giving less consistency
guarantees.
Process identifiers returned from consecutive calls of
erlang:process_next/1
may not be a consistent snapshot of all elements existing in the
table during
any of the calls. A process identifier is only guaranteed to be
returned from
a call to erlang:processes_next/1 if it was alive before the call to
erlang:processes_iterator/0 and was still alive when
erlang:processes_next/1 returned `none`.
Own Id: OTP-19369
Related Id(s): PR-9129
- Improved open debug for gen_tcp_socket (connect and listen) and
gen_udp_socket
(open).
Own Id: OTP-19386
- Module `re` has been updated to use PCRE2, which is mostly backward
compatible with PCRE.
The most noticeable incompatibilities are
- The default character encoding is pure ASCII and not Latin1.
Unicode support
is still available with options `unicode` and `ucp`.
- Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set
when a
regex is compiled and cannot be changed at matching for precompiled
regex.
Own Id: OTP-19431
Related Id(s): PR-9299
*** HIGHLIGHT ***
*** POTENTIAL INCOMPATIBILITY ***
- When booting the runtime system on a 32-bit computer with a single
core, the
boot code will try to minimize the peak memory use by disabling
parallel
loading of BEAM files.
Own Id: OTP-19450
Related Id(s): PR-9342
- A `socket` option `{otp,select_read}` has been added that enables
keeping a
socket in the VM select/poll set between calls to recv functions.
This increases throughput by reducing the number of calls to said
functions.
Own Id: OTP-19451
Related Id(s): PR-9344
- `erlc` will now write compiler warnings and errors to standard error,
instead
of standard output, in common with other language compilers.
Own Id: OTP-19460
Related Id(s): GH-9255, PR-9363
- Fixed the Windows build to always include `.pdb` files for all DLLs
and
executables to help with debugging.
Own Id: OTP-19465
Related Id(s): PR-9229
- Improve the naming of the (internal) esock mutex(es). It is now
possible to
configure (as in autoconf) the use of simple names for the esock
mutex(es).
Own Id: OTP-19472
Related Id(s): #9388
- An optimization for appending 0 bits to a binary was removed in patch
releases
for OTP versions 25, 26, and 27. This optimization has been
reintroduced in
Erlang/OTP 28.
Own Id: OTP-19473
Related Id(s): PR-8697, PR-9396
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
- When using `enif_select_read` (or `enif_select` with
`ERL_NIF_SELECT_READ`) on
systems with kernel polling enabled (that is most Unix systems), file
descriptors that are always re-enabled as soon as they trigger are
now part of
a specialized pollset just as `driver_select`. This reduces the CPU
usage in
such scenarios as the erts does not have to re-insert the FD
everytime it it
triggered. As a result of this optimization `socket` based reading
uses a
lot less CPU and achieves a higher throughput.
Own Id: OTP-19479
Related Id(s): PR-9275
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- The Windows installer no longer creates the `erl.ini` file, making
installations redistributable.
Own Id: OTP-19481
Related Id(s): PR-9330
- Added erlang:hibernate/0, which hibernates a process without
discarding the
stack.
Own Id: OTP-19503
Related Id(s): PR-9406
- The asmjit library (used by BeamJIT) has been updated to version
029075b84bf0161a761beb63e6eda519a29020db.
Own Id: OTP-19509
Related Id(s): PR-9495
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
- If a process being suspended using `erlang:suspend_process()`
currently is
waiting in a `receive ... after` expression, the timer for the
timeout will
now also be suspended until the process is resumed.
Own Id: OTP-19536
Related Id(s): PR-8670
*** POTENTIAL INCOMPATIBILITY ***
- A test module for TLS distribution over `socket` has been
implemented.
Own Id: OTP-19539
Related Id(s): PR-9511
- Upgrade pcre2 to 10.45
Own Id: OTP-19541
Related Id(s): PR-9582
> #### Full runtime dependencies of erts-16.0
>
> kernel-9.0, sasl-3.3, stdlib-4.1
# eunit-2.10
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
> #### Full runtime dependencies of eunit-2.10
>
> erts-9.0, kernel-5.3, stdlib-3.4
# inets-9.3.3
## Fixed Bugs and Malfunctions
- Replaced calls to deprecated `crypto:start()` with
`application:start(crypto)`.
Own Id: OTP-19485
Related Id(s): PR-8592
## Improvements and New Features
- Enhanced http client documentation.
Own Id: OTP-19520
Related Id(s): PR-9516
- Enhance made to mod_esi documentation
Own Id: OTP-19521
Related Id(s): PR-9472
> #### Full runtime dependencies of inets-9.3.3
>
> erts-14.0, kernel-9.0, mnesia-4.12, public_key-1.13, runtime_tools-
1.8.14,
> ssl-9.0, stdlib-5.0, stdlib-6.0
# jinterface-1.15
## Improvements and New Features
- The `.class` files of jinterface are now part of the prebuilt archive
using
Java 8.
Own Id: OTP-19308
Related Id(s): PR-8960
# kernel-10.3
## Fixed Bugs and Malfunctions
- Fixed an issue where output to the shell would not print the prompt
on a new
line.
Own Id: OTP-19228
Related Id(s): PR-8820
- When in `shell` is in `-noshell` mode, and in `latin1` encoding mode,
io
requests in latin1 encoding will not be translated to unicode and
back to
latin1.
Own Id: OTP-19296
Related Id(s): PR-9013
- Fixed a bug where a composing unicode character would bind to a
character not
available to the user and deleting that character would cause a
crash.
Own Id: OTP-19297
Related Id(s): PR-9005
- The `-noshell` mode has been updated to read data lazily from
standard
input. Before this fix any data would be read greedily which meant
that Erlang
could consume data not meant for it. It also meant that in order for
shell:start_interactive/0 to work on Windows an API that did not
support
reading of Unicode characters had to be used.
Own Id: OTP-19313
Related Id(s): GH-8113, PR-8962
- The Erlang shell no longer crashes when a shell prompt ends with an
escape
sequence.
Own Id: OTP-19414
Related Id(s): PR-9272
- code:get_doc/1 now works for cover-compiled modules.
Own Id: OTP-19513
Related Id(s): PR-9433
- An infinite loop in CNAME loop detection that can cause Out Of Memory
has been
fixed. This affected CNAME lookup with the internal DNS resolver.
Own Id: OTP-19544
Related Id(s): PR-9587, OTP-19545
## Improvements and New Features
- application:load/1 slows down as the number of directories in the
code path
increases because the call to code:where_is_file/1 for the '.app'
file must
scan each directory for the app.
`code_server` maintains a cache of the contents of directories in the
path.
Re-using that cache when searching for '.app' files in
application:load/1
may improve its runtime, especially when loading multiple
applications.
Own Id: OTP-19194
Related Id(s): PR-8078
- The `Erlang SSH daemon` now uses the same backend to handle multiline
functionality as the Erlang shell.
Own Id: OTP-19226
Related Id(s): PR-8805
- Added support for `SIGWINCH`, `SIGCONT`, and `SIGINFO` signals to
os:set_signal/2 where available.
Own Id: OTP-19278
Related Id(s): PR-8887, PR-8938
- Add net_kernel:allowed/0, it returns a list of nodes that are
explicitly
allowed to connect to the node by calling net_kernel:allow/1
Own Id: OTP-19287
Related Id(s): PR-8207
- Documentation chunks (EEP-48) has been updated to include the
following
reserved metadata fields: `behaviours`, `group`, `source_path`, and
`source_annos`. The compiler has also been updated to emit this
metadata. See
the EEP-48 documentation for more details.
Own Id: OTP-19306
Related Id(s): PR-8945, PR-8975
- The erpc:call/3, erpc:call/5, erpc:multicall/3, and erpc:multicall/5
functions now also accept an option map as last argument containing
the
`timeout` and `always_spawn` options. The `always_spawn` option can
be used in
order to ensure that the call operation will use a newly spawned
process when
executing the remote call.
Own Id: OTP-19343
Related Id(s): PR-8642
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- Improved open debug for gen_tcp_socket (connect and listen) and
gen_udp_socket
(open).
Own Id: OTP-19386
- `t:io:standard_error/0` has been updated to write via a NIF API
instead of a
port. This allows it to access the dirty-scheduler pool and make sure
that
writes have been written to the OSs `stderr` when io:format/3 and
equivalent
return.
Own Id: OTP-19401
Related Id(s): PR-9116
- Added the option `exception_on_failure` to os:cmd/2 to make os:cmd/2
raise
an exception if the command fails to execute.
Own Id: OTP-19404
Related Id(s): PR-9082
- A `socket` option `{otp,select_read}` has been added that enables
keeping a
socket in the VM select/poll set between calls to recv functions.
This increases throughput by reducing the number of calls to said
functions.
Own Id: OTP-19451
Related Id(s): PR-9344
- Add a configure chapter to the socket usage guide
Own Id: OTP-19522
Related Id(s): PR-9508
> #### Full runtime dependencies of kernel-10.3
>
> crypto-5.0, erts-15.1, sasl-3.0, stdlib-6.0
# megaco-4.8
## Fixed Bugs and Malfunctions
- Add missing spec and doc for exported functions.
Own Id: OTP-19523
## Improvements and New Features
- Nano seconds are now used for (example) meas result presentation.
Nanoseconds are now used, for example, in `meas` result
presentations.
Own Id: OTP-19403
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of megaco-4.8
>
> asn1-3.0, debugger-4.0, erts-12.0, et-1.5, kernel-8.0, runtime_tools-
1.8.14,
> stdlib-2.5
# mnesia-4.24
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
> #### Full runtime dependencies of mnesia-4.24
>
> erts-9.0, kernel-5.3, stdlib-5.0
# odbc-2.16
## Improvements and New Features
- Updated odbc configure to enable easier use of iodbc driver.
Own Id: OTP-19456
Related Id(s): PR-9083
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of odbc-2.16
>
> erts-6.0, kernel-3.0, stdlib-2.0
# os_mon-2.11
## Improvements and New Features
- `m:disksup` will now recognize HAMMER2 volumes.
Own Id: OTP-19207
Related Id(s): PR-8704
> #### Full runtime dependencies of os_mon-2.11
>
> erts-14.0, kernel-9.0, sasl-4.2.1, stdlib-5.0
# parsetools-2.7
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
> #### Full runtime dependencies of parsetools-2.7
>
> erts-6.0, kernel-3.0, stdlib-3.4
# public_key-1.18
## Improvements and New Features
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of public_key-1.18
>
> asn1-5.0, crypto-5.0, erts-13.0, kernel-8.0, stdlib-4.0
# runtime_tools-2.2
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of runtime_tools-2.2
>
> erts-15.0, kernel-10.0, mnesia-4.12, stdlib-6.0
# sasl-4.3
## Fixed Bugs and Malfunctions
- Fixed the documentation for the ExtraFiles option to
systools:make_tar/2.
Own Id: OTP-19279
Related Id(s): GH-8842, PR-8894
## Improvements and New Features
- `.appup` files are now included in releases in order to make it
possible to
create upgrade packages from an installed release.
Own Id: OTP-19398
Related Id(s): PR-8973
> #### Full runtime dependencies of sasl-4.3
>
> erts-15.0, kernel-6.0, stdlib-4.0, tools-2.6.14
# snmp-5.19
## Improvements and New Features
- EEP-69: Nominal Types has been implemented. As a side effect, nominal
types
can encode opaque types. We changed all opaque-handling logic and
improved
opaque warnings in Dialyzer.
All existing Erlang type systems are structural: two types are seen
as
equivalent if their structures are the same. Type comparisons are
based on the
structures of the types, not on how the user explicitly defines them.
For
example, in the following example, `meter()` and `foot()` are
equivalent. The
two types can be used interchangeably. Neither of them differ from
the basic
type `integer()`.
-type meter() :: integer().
-type foot() :: integer().
Nominal typing is an alternative type system, where two types are
equivalent
if and only if they are declared with the same type name. The EEP
proposes one
new syntax -nominal for declaring nominal types. Under nominal
typing,
`meter()` and `foot()` are no longer compatible. Whenever a function
expects
type `meter()`, passing in type `foot()` would result in a Dialyzer
error.
-nominal meter() :: integer().
-nominal foot() :: integer().
More nominal type-checking rules can be found in the EEP. It is worth
noting
that most work for adding nominal types and type-checking is in
`erl_types.erl`. The rest are changes that removed the previous
opaque
type-checking, and added an improved version of it using nominal
type-checking
with reworked warnings.
Backwards compatibility for opaque type-checking is not preserved by
this PR.
Previous opaque warnings can appear with slightly different wordings.
A new
kind of opaque warning `opaque_union` is added, together with a
Dialyzer
option `no_opaque_union` to turn this kind of warnings off.
Own Id: OTP-19364
Related Id(s): PR-9079
*** HIGHLIGHT ***
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of snmp-5.19
>
> crypto-4.6, erts-12.0, kernel-8.0, mnesia-4.12, runtime_tools-1.8.14,
> stdlib-5.0
# ssh-5.3
## Fixed Bugs and Malfunctions
- The implementation of the ssh server-side supervision tree has been
improved.
Own Id: OTP-19324
Related Id(s): GH-8223, PR-8968
## Improvements and New Features
- The `Erlang SSH daemon` now uses the same backend to handle multiline
functionality as the Erlang shell.
Own Id: OTP-19226
Related Id(s): PR-8805
- CBC algorithms are not offered by default. See Configuring algorithms
in SSH
if you wish to enable them.
Own Id: OTP-19420
Related Id(s): PR-9277
*** POTENTIAL INCOMPATIBILITY ***
- Daemon can be configured (bannerfun option) to send banner message at
the
beginning of user authentication.
Own Id: OTP-19535
Related Id(s): PR-9149
> #### Full runtime dependencies of ssh-5.3
>
> crypto-5.0, erts-14.0, kernel-10.3, public_key-1.6.1, runtime_tools-
1.15.1,
> stdlib-5.0, stdlib-6.0
# ssl-11.3
## Improvements and New Features
- Refactoring, minor optimizations and improved log printouts.
Own Id: OTP-19367
Related Id(s): PR-9019
- supervisor:which_child/2 is now used to make start-up code for
TLS-connections simpler and more straight forward, and to increase
stability
and maintainability of the ssl application.
Own Id: OTP-19406
Related Id(s): PR-9231
- The data handling for tls-v1.3 has been optimized.
Own Id: OTP-19430
Related Id(s): PR-9305
- Added experimental socket support.
Own Id: OTP-19463
Related Id(s): PR-9398
- Improve code health by removing dead code.
Own Id: OTP-19531
Related Id(s): PR-9563
- A test module for TLS distribution over `socket` has been
implemented.
Own Id: OTP-19539
Related Id(s): PR-9511
> #### Full runtime dependencies of ssl-11.3
>
> crypto-5.6, erts-16.0, inets-5.10.7, kernel-10.3, public_key-1.16.4,
> runtime_tools-1.15.1, stdlib-7.0
# stdlib-7.0
## Fixed Bugs and Malfunctions
- Shell help now orders the commands in alphabetical order.
Own Id: OTP-19161
Related Id(s): PR-8573
- `proc_lib:stop/1,3` (and in extension gen_server:stop/3,
gen_statem:stop/3
and so on) have been updated to not throw an error if the process to
be
stopped exits with the same reason as given to proc_lib:stop/3.
Own Id: OTP-19233
Related Id(s): PR-8772
*** POTENTIAL INCOMPATIBILITY ***
- The size of an atom in the Erlang source code was limited to 255
bytes in
previous releases, meaning that an atom containing only emojis could
contain
only 63 emojis.
While atoms are still only allowed to contain 255 characters, the
number of
bytes is no longer limited.
External tools that parse the `AtU8` chunk of a BEAM file directly
need to be
updated. Tools that use
`beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom
table
will continue to work.
Own Id: OTP-19285
Related Id(s): PR-8913
*** POTENTIAL INCOMPATIBILITY ***
- argparse:help/1 now accepts unicode:chardata/0.
Own Id: OTP-19303
Related Id(s): PR-8932
- The literals chunk in BEAM is no longer compressed, resulting in
slightly
smaller BEAM files when a BEAM file is stripped using
beam_lib:strip_files/1.
This is a potential incompatibility for tools that read and interpret
the
contents of the literal chunk. One way to update such tools to work
with the
new format is to retrieve the chunk using
`beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2).
Own Id: OTP-19323
Related Id(s): GH-8967, PR-8988
*** POTENTIAL INCOMPATIBILITY ***
- The previous digraph_utils:preorder/1 and digraph_utils:postorder/1
did
not start the traversal from root nodes. This fix makes both
traversals only
start or restart from a root node in one of the components, or an
arbitrary
node if no root node can be visited.
Own Id: OTP-19393
Related Id(s): PR-9171
- Auto-completion in the shell is now significantly faster for function
parameters that uses complex custom types.
Own Id: OTP-19413
Related Id(s): PR-9271
- Stringfying a non-latin1 atom will now produce a readable string
instead of
encoding each character using `\x{...}` escape sequences. Example:
-define(S(T), ??T).
atom() ->
?S('атом').
The `atom/0` function now returns `"'атом'"` instead of
`"'\\x{430}\\x{442}\\x{43E}\\x{43C}'"`.
Own Id: OTP-19421
Related Id(s): GH-9173, PR-9276
- A few minor issues were corrected in `syntax_tools`, as well in the
`erl_anno` module.
Own Id: OTP-19422
Related Id(s): PR-9253
- `m:dets` could print error messages to standard output when repairing
DETS
files. This has been changed to send the messages to `logger`.
`ets:fun2ms` would print an error message to standard output as well
as
returning an error tuple. The printing of the message has been
removed.
Own Id: OTP-19427
Related Id(s): PR-9232, PR-9446
- The functions for converting to and from the RFC1339 date and time
format
would not properly handle fractional seconds for negative times.
Own Id: OTP-19441
Related Id(s): GH-9279, PR-9280
- Replaced calls to deprecated `crypto:start()` with
`application:start(crypto)`.
Own Id: OTP-19485
Related Id(s): PR-8592
- Corrected the spec of ets:update_element/4.
Own Id: OTP-19514
Related Id(s): PR-9504
- Corrected the spec for ets:info/1.
Own Id: OTP-19515
Related Id(s): PR-9514
- Details in the hibernation implementation and time-out handling has
been
improved for `gen_statem`. In particular to avoid selective receive
when
cancelling a time-out.
Own Id: OTP-19540
Related Id(s): PR-9579
## Improvements and New Features
- Singleton type variables in an union type do not make sense from
Dialyzer's
point of view. The following example is ill-typed:
-spec run_test(Opts) -> term()
when Opts :: {join_specs, Bool} | {test, Bool}.
This used to be reported as a warning. In OTP-28, this is an error
Own Id: OTP-19125
Related Id(s): PR-8556
- By default, sets created by the `sets` module will now be represented
as
maps.
Own Id: OTP-19127
Related Id(s): PR-8429
- For various error types, the compiler now tries to suggest potential
fixes by
adding "did you mean ...?" at the end of error messages.
When a function is used with wrong arity, the compiler will try to
suggest a
defined function with the same name but a different arity. For
example, given
the following module:
-module(typos).
-export([t/0]).
bar(A) -> A.
bar(A,A,A) -> A.
bar(A,A,A,A) -> A.
t() -> bar(0, 0).
The compiler will emit the following message:
typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4?
% 6| t() -> bar(0, 0).
% | ^
For compiler errors that can easily be caused by typos, the compiler
will try
to suggest what the correct variable or function name, could be. For
example,
given the following module:
-module(typos).
-export([bar/2]).
bar(A0, B0) ->
A + B.
the compiler will emit the following error messages:
typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'?
% 5| A + B.
% | ^
typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'?
% 5| A + B.
% | ^
Error types that now suggest correct arities: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `bad_nowarn_bif_clash`,
`undefined_function`.
Error types that now suggest correct names: `bad_inline`,
`undefined_nif`,
`bad_nowarn_unused_function`, `undefined_on_load`,
`undefined_function`,
`undefined_record`, `undefined_field`, `unbound_var`.
Using a function with wrong arity has higher precedence than having a
typo in
the function name. If the compiler can find a defined function with
the same
name but a different arity, it will not suggest a defined function
with a
close-enough name, regardless of arity.
Own Id: OTP-19180
Related Id(s): PR-8699, PR-9094
*** HIGHLIGHT ***
- Comprehensions have been extended with zip generators according to
EEP 73.
Example:
1> [A+B || A <- [1,2,3] && B <- [4,5,6]].
[5,7,9]
Own Id: OTP-19184
Related Id(s): PR-8926
*** HIGHLIGHT ***
- Before restarting a child, a supervisor must check if the restart
limit is
reached. This adds a penalty to the overall restart time, which
should be kept
low. The algorithm has been optimized from 2\*O(n) to O(n) behavior.
Own Id: OTP-19204
Related Id(s): PR-8261
- Added the possibility to configure shell docs column width through
the stdlib
parameter `shell_docs_columns`.
Own Id: OTP-19224
Related Id(s): PR-8651
- The io:setopts/2 function now accepts the `line_history` option for
more
explicit handling of when to save shell history.
Own Id: OTP-19230
Related Id(s): PR-8792
- The shell now prints a help message explaining how to interrupt a
running
command when stuck executing a command for longer than 5 seconds.
Own Id: OTP-19231
Related Id(s): PR-8793
- Binaries can now be used as input to
calendar:rfc3339_to_system_time/2, and
produced as output of calendar:system_time_to_rfc3339/2.
Own Id: OTP-19250
Related Id(s): PR-8812
- The `erl -noshell` mode has been updated to have two sub modes called
`raw`
and `cooked`, where `cooked` is the old default behaviour and `raw`
can be
used to bypass the line-editing support of the native terminal. Using
`raw`
mode it is possible to read keystrokes as they happen without the
user having
to press Enter. Also, the `raw` mode does not echo the typed
characters to
stdout. An example of how to create a tic-tac-toe game using this
mechanism is
included in the documentation.
Own Id: OTP-19314
Related Id(s): GH-8037, PR-8962
*** HIGHLIGHT ***
- Added io:get_password/0 that can read passwords from stdin when in
"raw"
`-noshell` mode.
Own Id: OTP-19315
Related Id(s): PR-8962, PR-9006
- New strict generators have been added for comprehensions.
The currently existing generators are "relaxed": they ignore terms in
the
right-hand side expression that do not match the left-hand side
pattern.
The new strict generators fail with exception `badmatch` if a pattern
doesn't
match.
Examples:
Using the current relaxed generator operator `<-`, any element not
matching
the pattern `{_,_}` will be silently discarded:
1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]].
[{ok,1},{error,2}]
If the intention is that all lists processed by a list comprehension
must only
contain tuples of size two, using the new strict version of the
operator
ensures that term not matching will cause a crash:
2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]].
** exception error: no match of right hand side value ok
Using the strict generator operator to mark the intention that all
list
elements must match the pattern could help finding mistakes quicker
if
something unpexected is added to the list processed by the generator.
The strict version for bitstring generators is `<:=`.
Own Id: OTP-19317
Related Id(s): PR-8625
*** HIGHLIGHT ***
- New options for suppressing behaviour warnings have been added:
- `nowarn_conflicting_behaviours`
- `nowarn_undefined_behaviour_func`
- `nowarn_undefined_behaviour`
- `nowarn_undefined_behaviour_callbacks`
- `nowarn_ill_defined_behaviour_callbacks`
- `nowarn_ill_defined_optional_callbacks`
Own Id: OTP-19334
Related Id(s): GH-8985, PR-9020
- The `join(Binaries, Separator)` function that joins a list of
binaries has
been added to the `binary` module.
Own Id: OTP-19337
Related Id(s): GH-8099, PR-8100
*** HIGHLIGHT ***
- The supervisor:which_child/2 function has been added to facilitate
getting
the pid of a sibling process; that is a process under same supervisor
as the
process that calls to call the new function.
Own Id: OTP-19345
Related Id(s): PR-8976
- The function erl_anno:set_end_location/2 for setting the end location
of a
token has been added.
Own Id: OTP-19354
Related Id(s): PR-8966
- Added a warning for calling non-exported functions with the remote
function
call syntax from the same module, and likewise for the remote fun
syntax.
Own Id: OTP-19371
Related Id(s): GH-9092, PR-9095
- The `warn_deprecated_catch` option enables warnings for use of old-
style catch
expressions on the form `catch Expr` instead of the modern
`try ... catch ... end`. To prevent new uses of uses of old catches
to be
added, this compiler option can be enabled on the project level and
`-compile(nowarn_deprecated_catch).` added to individual files that
still
contain old catches.
Own Id: OTP-19425
Related Id(s): PR-9154
- Module `re` has been updated to use PCRE2, which is mostly backward
compatible with PCRE.
The most noticeable incompatibilities are
- The default character encoding is pure ASCII and not Latin1.
Unicode support
is still available with options `unicode` and `ucp`.
- Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set
when a
regex is compiled and cannot be changed at matching for precompiled
regex.
Own Id: OTP-19431
Related Id(s): PR-9299
*** HIGHLIGHT ***
*** POTENTIAL INCOMPATIBILITY ***
- Defining a fun in terms of an imported function is not allowed.
Before this
release, the compiler would not catch this kind of error if the name
of the
imported function happened to be a BIF. Consider this example:
-module(fun_example).
-export([foo/0, bar/0]).
-import(m, [max/2, not_a_bif/0]).
foo() ->
fun max/2.
bar() ->
fun not_a_bif/0.
The compiler in Erlang/OTP 27 would generate the following messages:
fun_example.erl:9:5: function not_a_bif/0 undefined
% 9| fun not_a_bif/0.
% | ^
fun_example.erl:3:2: Warning: import directive overrides auto-
imported BIF max/2 --
use "-compile({no_auto_import,[max/2]})." to resolve name clash
% 3| -import(m, [max/2, not_a_bif/0]).
% | ^
That is, there would be a (cryptic) error for `fun not_a_bif/0`, but
only a
warning for `fun max/2`.
When compiling with this release, both attempts to create a fun will
result in
error messages (as well as a warning):
fun_example.erl:6:5: creating a fun from imported name max/2 is
not allowed
% 6| fun max/2.
% | ^
fun_example.erl:9:5: creating a fun from imported name
not_a_bif/0 is not allowed
% 9| fun not_a_bif/0.
% | ^
fun_example.erl:3:2: Warning: import directive overrides auto-
imported BIF max/2 --
use "-compile({no_auto_import,[max/2]})." to resolve name clash
% 3| -import(m, [max/2, not_a_bif/0]).
% | ^
Also, attempting to call a local function having the same name as
auto-imported BIF would result in an error if the BIF was added to
Erlang/OTP
before R14, and a warning for newer BIFs. This has been changed to
always emit
a warning. For example:
-module(bif_example).
-export([bar/1]).
bar(B) ->
is_boolean(B).
is_boolean(B) ->
B =:= true orelse B =:= false.
will now result in the following warning instead of an error:
if_example.erl:5:5: Warning: ambiguous call of overridden auto-
imported BIF is_boolean/1 --
use erlang:is_boolean/1 or "-
compile({no_auto_import,[is_boolean/1]})." to resolve name clash
% 5| is_boolean(B).
% | ^
Own Id: OTP-19432
Related Id(s): PR-9246
- It is now possible to use any base for floating point numbers as
described in
EEP 75: Based Floating Point Literals.
Computers represent floating point numbers in binary, but such
numbers are
typically printed using base ten, for example 0.314159265e1. To
maintain exact
bit-level precision when converting numbers to and from text, it is
better to
use a base that matches the internally used base, such as 16 for a
compact but
still exact representation, or 2 for visualizing or writing down the
exact
internal format. One particular case where such exact representations
are
useful is in code generating tools.
Examples:
> 2#0.111.
0.875
> 16#fefe.fefe#e16.
1.2041849337671418e24
Own Id: OTP-19452
Related Id(s): PR-9106
*** HIGHLIGHT ***
- The callback function `handle_continue/2` in `gen_server` callback
modules is
now cached like the others, thanks to code cleanup and optimization
of the
internal behaviour loop.
This should only improve performance, not affect functionality.
Own Id: OTP-19474
Related Id(s): PR-9333
- Encoding done by the `json` module has been optimized.
Own Id: OTP-19476
Related Id(s): PR-9251
- There is a new `zstd` module that does Zstandard compression.
Own Id: OTP-19477
Related Id(s): PR-9316
*** HIGHLIGHT ***
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
- Functions of a module can now be grouped in the shell code completion
by using
the _group_ key in the _-doc_ attribute e.g. ``` -
doc(#{group=><<"Public
API">>). fetch()->...
Functions, callbacks and types in the module reference
documentation of OTP is now grouped using this feature.
Own Id: OTP-19483
Related Id(s): [PR-9408]
- Added calendar:universal_time_to_system_time/1,2 and
calendar:local_time_to_system_time/1,2
Own Id: OTP-19505
Related Id(s): PR-9445
- Improve error messages for json:decode/1.
Own Id: OTP-19508
Related Id(s): PR-9484
- ETS `heir` can be set without getting an `ETS-TRANSFER` message.
Useful when
the heir is a supervisor process that cannot handle custom messages.
Own Id: OTP-19512
Related Id(s): PR-7970
- Added support for the Unicode 16 standard.
Own Id: OTP-19516
Related Id(s): PR-9141, PR-9518
- When documenting a function or type that needs to deal with
durations, usually
we can document it as "time in milliseconds". Since the `timer`
family of
functions (`hms`, `hours`, `seconds`, ...) all return time in
milliseconds, it
is useful to be able to use this type in type specifications.
Own Id: OTP-19526
Related Id(s): PR-9515
- A new event time-out has been implemented in `gen_server`, that
behaves more
like the one in `gen_statem`. Documentation and test cases are
planned for a
later patch.
Own Id: OTP-19537
Related Id(s): PR-9287
- Line numbers used to be reported in the following way:
1> lists:last([]).
** exception error: no function clause matching lists:last([])
(lists.erl, line 389)
Starting from Erlang/OTP 28, line numbers are now reported in the
following
way:
1> lists:last([]).
** exception error: no function clause matching lists:last([])
(lists.erl:389)
Own Id: OTP-19538
Related Id(s): PR-9468
*** HIGHLIGHT ***
- Upgrade pcre2 to 10.45
Own Id: OTP-19541
Related Id(s): PR-9582
> #### Full runtime dependencies of stdlib-7.0
>
> compiler-5.0, crypto-4.5, erts-16.0, kernel-10.0, sasl-3.0,
syntax_tools-3.2.1
# syntax_tools-4.0
## Fixed Bugs and Malfunctions
- A few minor issues were corrected in `syntax_tools`, as well in the
`erl_anno` module.
Own Id: OTP-19422
Related Id(s): PR-9253
## Improvements and New Features
- Comprehensions have been extended with zip generators according to
EEP 73.
Example:
1> [A+B || A <- [1,2,3] && B <- [4,5,6]].
[5,7,9]
Own Id: OTP-19184
Related Id(s): PR-8926
*** HIGHLIGHT ***
- New strict generators have been added for comprehensions.
The currently existing generators are "relaxed": they ignore terms in
the
right-hand side expression that do not match the left-hand side
pattern.
The new strict generators fail with exception `badmatch` if a pattern
doesn't
match.
Examples:
Using the current relaxed generator operator `<-`, any element not
matching
the pattern `{_,_}` will be silently discarded:
1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]].
[{ok,1},{error,2}]
If the intention is that all lists processed by a list comprehension
must only
contain tuples of size two, using the new strict version of the
operator
ensures that term not matching will cause a crash:
2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]].
** exception error: no match of right hand side value ok
Using the strict generator operator to mark the intention that all
list
elements must match the pattern could help finding mistakes quicker
if
something unpexected is added to the list processed by the generator.
The strict version for bitstring generators is `<:=`.
Own Id: OTP-19317
Related Id(s): PR-8625
*** HIGHLIGHT ***
- Fixed licenses in files and added ORT curations to the following
apps: otp,
eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and
ERTS.
Own Id: OTP-19478
Related Id(s): PR-9376, PR-9402
> #### Full runtime dependencies of syntax_tools-4.0
>
> compiler-9.0, erts-16.0, kernel-10.3, stdlib-7.0
# tools-4.1.2
## Fixed Bugs and Malfunctions
- A crash has been eliminated in tprof:collect/0 when unloading a
module while
collecting traces.
Own Id: OTP-19135
Related Id(s): GH-8483, PR-8547
- Improved the `indent-region` Emacs command, which could indent badly
when
inside multiline string.
Own Id: OTP-19396
Related Id(s): PR-9186
- eprof:start_profiling/3 can now return information about which
process it
failed to trace.
Own Id: OTP-19419
Related Id(s): PR-9219
- Fixed a race condition when processes cause the Cover server to be
started at
the same time.
Own Id: OTP-19517
Related Id(s): PR-9124
> #### Full runtime dependencies of tools-4.1.2
>
> compiler-8.5, erts-15.0, erts-15.0, kernel-10.0, runtime_tools-2.1,
stdlib-6.0
# wx-2.5
## Improvements and New Features
- Added support for compiling Erlang/OTP for Windows on ARM64.
Own Id: OTP-19480
Related Id(s): PR-8734
- When compiling C/C++ code on Unix systems, the compiler hardening
flags
suggested by the Open Source Security Foundation are now enabled by
default.
To disable them, pass `--disable-security-hardening-flags` to
`configure`.
Own Id: OTP-19519
Related Id(s): PR-9441
> #### Full runtime dependencies of wx-2.5
>
> erts-12.0, kernel-8.0, stdlib-5.0
# xmerl-2.1.2
## Fixed Bugs and Malfunctions
- With this change all public functions in xmerl have specs.
Own Id: OTP-19534
Related Id(s): PR-9327
> #### Full runtime dependencies of xmerl-2.1.2
>
> erts-6.0, kernel-8.4, stdlib-2.5
# Thanks to
Adam Wight, Aleksander Lisiecki, Alexandre Rodrigues, Anders Ågren
Thuné, Andrea
Leopardi, Ariel Otilibili, Benedikt Reinartz, Brujo Benavides, Chris
Freeze,
Christophe De Troyer, Cocoa, Dairon Medina Caro, Daniel Gorin, Dániel
Szoboszlay, dependabotbot, Dmitri Vereshchagin, Douglas Vought, Egor
Ignatov,
Eksperimental, Frank Hunleth, Fredrik Frantzen, Frej Drejhammar, Gary
Rennie,
Hichem Fantar, iri, Isabell H, Jan Uhlig, Jean-Sébastien Pédron, João
Henrique
Ferreira de Freitas, Johannes Christ, Jonas Bernoulli, Jonatan Kłosko,
José
Valim, Juan Barrios, Julian Doherty, Keyhan Jannat Khah ☕, Kirill A.
Korinsky,
lucioleKi, Lukasz Samson, Maria Scott, Mario Idival, Mario Uher, Marko
Mindek,
Martin Davidsson, Matwey V. Kornilov, Maxim Fedorov, Michael Davis,
Michael
Neumann, Nelson Vides, Onno Vos, preciz, Richard Carlsson, Roberto
Aloi, Robin
Morisset, Roeland van Batenburg, ruslandoga, S0AndS0, sabiwara, Sergei
Shuvatov,
siiky, Simon Cornish, Stavros Aronis, Steffen Deusch, Tobias Pfeiffer,
Tomer,
Vance Shipley, William Fank Thomé, williamthome, William Yang, Wojtek
Mach
More information about the erlang-announce
mailing list