4  Upcoming Potential Incompatibilities

4 Upcoming Potential Incompatibilities

This document lists planned upcoming potential incompatibilities in Erlang/OTP.

As of OTP 27, the functions erlang:fun_info/1,2 will always say that the local init process created all funs, regardless of which process or node the fun was originally created on.

In OTP 28, the {pid,_}element will be removed altogether.

As of OTP 27, the maybe_expr feature will be approved and enabled by default. That means that code that uses the unquoted atom maybe will fail to compile. All uses of maybe as an atom will need to be quoted. Alternatively, as a short-term solution, the maybe_expr feature can be disabled.

It is recommend to quote all uses of the atom maybe as soon as possible. The compiler option warn_keywords can be used to emit warnings about all occurrences of maybe without quotes.

The functionality of module re is currently provided by the PCRE library, which is no longer actively maintained. Therefore, in OTP 27, we will switch to a different regular expression library.

The source code for PCRE used by the re module has been modified by the OTP team to ensure that a regular expression match would yield when matching huge input binaries and/or when using demanding (back-tracking) regular expressions. Because of the those modifications, moving to a new version of PCRE has always been a time-consuming process because all of the modifications had to be applied by hand again to the updated PCRE source code.

Most likely, the new regular expression library will be RE2. RE2 guarantees that the match time is linear in the length of input string, and it also eschews recursion to avoid stack overflow. That should make it possible to use RE2 without modifying its source code. For more information about why RE2 is a good choice, see WhyRE2.

Some of implications of this change are:

  • We expect that the functions in the re module will continue to be supported, although some of the options are likely to be dis-continued.

  • It is likely that only pattern matching of UTF8-encoded binaries will be supported (not Latin1-encoded binaries).

  • In order to guarantee the linear-time performance, RE2 does not support all the constructs in regular expression patterns that PCRE do. For example, backreferences and look-around assertions are not supported. See Syntax for a description of what RE2 supports.

  • Compiling a regular expression is likely to be slower, and thus more can be gained by explicitly compiling the regular expression before matching with it.

0.0 and -0.0 will no longer be exactly equal

Currently, the floating point numbers 0.0 and -0.0 have distinct internal representations. That can be seen if they are converted to binaries:

1> <<0.0/float>>.
<<0,0,0,0,0,0,0,0>>
2> <<-0.0/float>>.
<<128,0,0,0,0,0,0,0>>

However, when they are matched against each other or compared using the =:= operator, they are considered to be equal. Thus, 0.0 =:= -0.0 currently returns true.

In Erlang/OTP 27, 0.0 =:= -0.0 will return false, and matching 0.0 against -0.0 will fail. When used as map keys, 0.0 and -0.0 will be considered to be distinct.

The == operator will continue to return true for 0.0 == -0.0.

To help to find code that might need to be revised, in OTP 27 there will be a new compiler warning when matching against 0.0 or comparing to that value using the =:= operator. The warning can be suppressed by matching against +0.0 instead of 0.0.

We plan to introduce the same warning in OTP 26.1, but by default it will be disabled.

Before Erlang/OTP 26, the compiler would silenty accept the following spec:

-spec f(Opts) -> term() when
    Opts :: {ok, Unknown} | {error, Unknown}.
f(_) -> error.

In OTP 26, the compiler emits a warning pointing out that the type variable Unknown is unbound:

t.erl:6:18: Warning: type variable 'Unknown' is only used once (is unbound)
%    6|     Opts :: {ok, Unknown} | {error, Unknown}.
%     |                  ^

In OTP 27, that warning will become an error.

Escripts will be compiled by default instead of interpreted. That means that the compiler application must be available.

The old behavior of interpreting escripts can be restored by adding the following line to the script file:

-mode(interpret).

In OTP 28, support for interpreting an escript will be removed.

-code_path_choice will default to strict

This command line option controls if paths given in the command line, boot scripts, and the code server should be interpreted as is strict or relaxed.

OTP 26 and earlier defaults to relaxed, which means -pa myapp/ebin would attempt to load -pa myapp/ebin and -pa myapp/myapp/ebin. The option will default to strict in OTP 27.

OTP 26 and earlier allows an application to have part of its directories as regular folders and others as archives. This functionality was previously used by reltool but it is no longer the case from OTP 26. Support for archive fallbacks will be removed from the code server in OTP 27.

Before Erlang/OTP 27 a sequence of 3 or more double-quote characters was grouped in pairs each meaning the empty string and if there was an odd number the last character was the start of a string. The empty strings were then concatenated and effectively disappeared.

In Erlang/OTP 27; 3 or more double-quote characters are interpreted as the start of a "Triple-Quoted String". See EEP 64.

Here follows some examples of code that would change meaning. Note that all these examples before Erlang/OTP 27.0 was strange since there was no sensible reason to write like that. 

"""String Content"""
%% Was interpreted as
"" "String Content" ""
%% Which becomes
"String Content"
%%
%% In OTP 27 it is instead a syntax error since no text is allowed
%% on the line after an opening triple-quote
      
"""
String Content
"""
%% Was interpreted as
"" "
String Content
" ""
%% Which becomes
"
String Content
"
%%
%% In OTP 27 it is instead interpreted as a
%% Triple-Quoted String equivalent to
"String Content"
      
""""
++ foo() ++
""""
%% Became
"" ++ foo() ++ ""
%%
%% In OTP 27 it is instead interpreted as a
%% Triple-Quoted String (triple-or-more) equivalent to
"++ foo() ++"

From Erlang/OTP 26.1 up to 26.2 the compiler issues a warning for a sequence of 3 or more double-quote characters since that is almost certainly a mistake or something like a result of bad automatic code generation. If a users gets that warning, the code should be corrected for example by inserting appropriate spaces between the empty strings, or removing the redundant ones alltogether, which will have the same meaning before and after Erlang/OTP 27.

From Erlang/OTP 26.2 up to 27.0 this is improved so the compiler instead issues a warning for adjacent string literals without intervening white space, which effectively is the same at a string start, but also covers the same situation at a string end.

As of OTP 28, the function erlang:fun_info/1 will not include the {pid,_} element and the function erlang:fun_info/2 will no longer accept pid as the second argument.

Escripts will be compiled, and it will no longer be possible to force an escript to be interpreted by using the directive -mode(interpret).

As of OTP 29, the maybe_expr feature will become permanent and no longer possible to disable. All uses of maybe as an atom will need to be quoted.

It is recommend to quote all uses of the atom maybe as soon as possible. The compiler option warn_keywords can be used to emit warnings about all occurrences of maybe without quotes.

Copyright © 2019-2024 Ericsson AB. All Rights Reserved.