v1.10.0

Support for Erlang/OTP 21+

Elixir v1.10 requires Erlang/OTP 21+, allowing Elixir to integrate with Erlang/OTP's new logger. Currently, this means that the logger level, logger metadata, as well as all log messages are now shared between Erlang and Elixir APIs.

We will continue improving the relationship between the logging systems in future releases. In particular, we plan to expose all log levels and runtime filtering functionalities available in Erlang directly into Elixir in the next Elixir version.

This release also adds two new guards, is_struct/1 and is_map_key/2, thanks to the strict requirement on Erlang/OTP 21+.

Releases improvements

Elixir v1.9 introduced releases as a mechanism to package self-contained applications. Elixir v1.10 further improves releases with bug fixes and new enhancements based on feedback we got from the community. The highlights are:

• Allow the dual boot system of releases to be disabled on environments that are boot-time sensitive, such as embedded devices

• Track and raise if compile-time configuration is set or changes at runtime (more in the next section)

• Support for easily adding extra files to releases via overlays

• Allow RELEASE_DISTRIBUTION to be set to none in order to fully disable it

• Add a built-in :tar step that automatically packages releases

See the full CHANGELOG for more improvements.

Improvements to sort-based APIs in Enum

Enum.sort/1 in Elixir by default sorts from lowest to highest:

iex> Enum.sort(["banana", "apple", "pineapple"])
["apple", "banana", "pineapple"]

If you want to sort from highest to lowest, you need to call Enum.sort/2 with a custom sorting function, such as Enum.sort(collection, &>=/2), which is not immediately obvious to someone reading the code:

iex> Enum.sort(["banana", "apple", "pineapple"], &>=/2)
["pineapple", "banana", "apple"]

Furthermore, comparison operators, such as <= and >=, perform structural sorting, instead of a semantic one. For example, using >= to sort dates descendingly won't yield the correct result:

iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]])
[~D[2020-01-01], ~D[2019-12-31]]

To perform proper semantic comparison for dates, one would also need to pass a custom sorting function:

iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], &(Date.compare(&1, &2) != :lt))
[~D[2019-12-31], ~D[2020-01-01]]

Elixir v1.10 streamlines the sorting functions by introducing both :asc and :desc shortcuts:

iex> Enum.sort(["banana", "apple", "pineapple"], :asc)
["apple", "banana", "pineapple"]
iex> Enum.sort(["banana", "apple", "pineapple"], :desc)
["pineapple", "banana", "apple"]

As well as adding the possibility to pass a module to perform semantic comparisons. For example, to sort dates, one now only needs to pass the Date module or even {:desc, Date} for descending semantical sort:

iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], Date)
[~D[2019-12-31], ~D[2020-01-01]]
iex> Enum.sort([~D[2019-12-31], ~D[2020-01-01]], {:desc, Date})
[~D[2020-01-01], ~D[2019-12-31]]

These API improvements make the code more concise and readable and they have also been added to Enum.sort_by, Enum.min_by, Enum.max_by, and friends.

Tracking of compile-time configuration

In Elixir, we organize our code in applications. Libraries, your dependencies, and your own project are all separate applications. All applications in Elixir also come with an application environment.

The application environment is a key-value store that allows us to configure said application. While reading the application environment at runtime is the preferred approach, in some rare occasions you may want to use the application environment to configure the compilation of a certain project. This is often done by calling Application.get_env/3 outside of a function:

defmodule MyApp.DBClient do
  @db_host Application.get_env(:my_app, :db_host, "db.local")
  def start_link() do
    SomeLib.DBClient.start_link(host: @db_host)
  end
end

This approach has one big limitation: if you change the value of the application environment after the code is compiled, the value used at runtime is not going to change! For example, if you are using mix release and your config/releases.exs has:

config :my_app, :db_host, "db.production"

Because config/releases.exs is read after the code is compiled, the new value will have no effect as the code was compiled to connect to "db.local".

Of course, the obvious solution to this mismatch is to not read the application environment at compilation time in the first place, and instead move the code to inside a function:

defmodule MyApp.DBClient do
  def start_link() do
    SomeLib.DBClient.start_link(host: db_host())
  end
  defp db_host() do
    Application.get_env(:my_app, :db_host, "db.local")
  end
end

While this is the preferred approach, there are still two scenarios we need to address:

1. Not everyone may be aware of this pitfall, so they will mistakenly read the application environemnt at compile-time, until they are bitten by this behaviour

2. In rare occasions, you trully need to read the application environment at compile-time, and you want to be warned when you try to configure at runtime something that is valid only at compilation time

Elixir v1.10 aims to solve these two scenarios by introducing a Application.compile_env/3 function. For example, to read the value at compile time, you can now do:

@db_host Application.compile_env(:my_app, :db_host, "db.local")

By using compile_env/3, Elixir will store the values used during compilation and compare them with the runtime values whenever your system starts, raising an error in case they differ. This helps developers ensure they are running their production systems with the configuration they intend to.

In future versions, we will deprecate the use Application.get_env at compile-time with a clear message pointing users to configuration best practices, effectively addressing the scenario where users read from the application environment at compile time unaware of its pitfalls.

Compiler tracing

This release brings enhancements to the Elixir compiler and adds new capabilities for developers to listen to compilation events.

In previous Elixir versions, Elixir would compile a database of cross references between modules (such as function calls, references, structs, etc) for each project in order to perform all kinds of checks, such as deprecations and undefined functions.

Although this database was not public, developers would still use it to run their own checks against their projects. With time, developers would request more data to be included in the database, which was problematic as Elixir itself did not have a use for the additional data, and the database was not meant to be used externally in the first place.

In Elixir v1.10, we have addressed these problems by introducing compiler tracing. The compiler tracing allows developers to listen to events as they are emitted by the compiler, so they can store all of the information they need - and only the information they need.

Elixir itself is using the new compiler tracing to provide new functionality. One advantage of this approach is that developers can now disable undefined function warnings directly on the callsite. For example, imagine you have an optional dependency which may not be available in some cases. You can tell the compiler to skip warning on calls to optional modules with:

@compile {:no_warn_undefined, OptionalDependency}
defdelegate my_function_call(arg), to: OptionalDependency

Previously, this information had to be added to the overall project configuration, which was far away from where the optional call effectively happened.

Other enhancements

Elixir's calendar data types got many improvements, such as sigil support for third-party calendars, as well as the additions of DateTime.now!/2, DateTime.shift_zone!/3, and NaiveDateTime.local_now/0.

There are many improvements related to Elixir's AST in this release too. First of all, Code.string_to_quoted/2 has two new options, :token_metadata and :literal_encoder, that give more control over Elixir's parser. This information was already available to the Elixir code formatter and has now been made public. We have also extensively documented all of Elixir's AST metadata. These changes alongside compiler tracing means static analyzers and IDE integrations have a better foundation to analyze the source code.

ExUnit, our test framework, ships two small but important improvements: ExUnit.CaptureIO can now be used by tests that run concurrently and we have added "pattern-matching diffing". To understand the last feature, take this code:

assert %{"status" => 200, "body" => %{"key" => "foo"}} = json_payload

Now imagine that json_payload is a large JSON blob and the "key" inside the "body" did not have value of "foo". In previous Elixir versions, if the assertion failed, Elixir would print the right side and let you up to your own devices to figure out what went wrong. In Elixir v1.10, we diff the data structure against the pattern so you can see exactly which parts of the data matched the pattern and which ones did not. Note ExUnit already performed diffing when comparing data types, this new version adds diffing when matching data agaainst a pattern.

CHANGELOG

1. Enhancements

Elixir

• [Application] Add Application.compile_env/3 and Application.compile_env!/2 for reading values at compilation time and tracking if they accidentally change during runtime
• [Calendar] Allow custom calendar representations in calendar sigils
  ...

v1.10.0-rc.0

Checksums

• Precompiled.zip SHA1: ed80d00c3d805da50787f8dd9d0d02acf6ae5668
• Precompiled.zip SHA512: b878d802c9ad9d9d8ee2493c653d4e5335f68fce2c237e0e5c13c2af0c8855eb6219842b480b794fc3076606a4832c90932bed8262ce4c0164f5af6756f26997
• Docs.zip SHA1: c6fac84cca76c6ff9450e9dfc305e1db24ecee75
• Docs.zip SHA512: 3e4eaa181ab9cd002ff0dbdd4790a630e422fcbfd35d0fe10987bfac0ffa8ceeda313e1c06381063426ba02a63b44f959c5e4151663dcdd612e77a68a06888fa

v1.9.4

1. Bug fixes

Mix

• [mix local.hex] Remove invalid deprecation warning on mix local.hex command

Checksums

• Precompiled.zip SHA1: ec4c7d15b28373b8fd7025b4502b7f2036229f20
• Precompiled.zip SHA512: f86170bde3b3ad3d1365f34f77ab9cb424c4638a4067fd7d509787c03dea0d40061ef1a2c8d1d9e42bec65b8cda8c1bf32801e4712531eeaef50e0cd53ac2369
• Docs.zip SHA1: 3c7496c77c9ce303d1b9eceb036ec2e8154f6347
• Docs.zip SHA512: b7f9efad208e52432302a04799a66f10ea217ecc01eae056c1204e17cc5ce232780c1b9c8b50a33004b180f1bc51a86b9de5ef8502c1428e9c2b50050f0ebe60

v1.9.3

This release deprecates the use of URLs on mix archive.install, mix escript.install, and mix local.rebar. Support for passing URLs to said commands will be fully removed on Elixir v1.10, as they are unsafe. Thanks to Bram Verburg for the report and for providing a fix.

The alternative is straight-forward: you can simply download the artifact via the command line and then invoke the command with a file system path. For example, instead of:

$ mix archive.install https://example.org/installer.ez

You can execute on Unix (Linux, MacOS X):

$ wget https://example.org/installer.ez
$ mix archive.install installer.ez

or

$ curl -o installer.ez https://example.org/installer.ez
$ mix archive.install installer.ez

On Windows (Win7 or later):

> powershell -Command "Invoke-WebRequest https://example.org/installer.ez -OutFile installer.ez"
> mix archive.install installer.ez

or

> powershell -Command "(New-Object Net.WebClient).DownloadFile('https://example.org/installer.ez', 'installer.ez')"
> mix archive.install installer.ez

Note that, if you are a library author, consider providing installable escripts and archives through Hex, such as Phoenix:

$ mix archive.install hex phx_new

Installations through Hex are always safe and they come with version management and all other benefits from Hex too.

1. Enhancements

Mix

• [mix release] Add :tar option for releases to create a tarball

2. Bug fixes

Mix

• [mix release] Use default_release option when name is not given
• [mix release] Make release's boot script contents deterministic

3. Deprecations

Mix

• [mix archive.install] Warn when installing from URI
• [mix escript.install] Warn when installing from URI
• [mix local.rebar] Warn when installing from URI

Checksums

• Precompiled.zip SHA1: 8bcf1cca9a946db02af570a78b007e9424cd933f
• Precompiled.zip SHA512: e5252721b5a08f48c5988027cb765f9317e7e271e52f3f4a3ebcb77581eb584c9aa0cdb216e12a3d626f725964fde2af84ce2241ac8b04d034dd461206c17f54
• Docs.zip SHA1: a7935d18ec5a04dd7a3e631483e31b6fbe6a8b1d
• Docs.zip SHA512: 59a53ed8a83920afaf087ecd6edb39a6401d9c917a113ce0ea7ad05612a33f35f188e3673e50c7b068b614c6121461095b32a4385d9a838e8b6461274a9ac6d6

v1.9.2

1. Enhancements

Mix

• [mix release] Allow {:from_app, app_name} as a version for releases

2. Bug fixes

Elixir

• [Kernel] Ensure compilation works for a variable named super
• [Kernel] Ensure capture operator of a local function expands correctly inside a macro
• [Regex] Ensure dynamic recompilation of regexes considers options. This fixes an issue where parsing the protocol in URI.parse/1 seemingly looked case sensitive when running Elixir precompiled on another machine

Mix

• [mix release] Use Base.encode32 when generating cookie to avoid unsafe chars
• [mix release] Fix install command on Windows
• [mix release] Quote executable path on Windows to ensure it works on directories with spaces

Checksums

• Precompiled.zip SHA1: d638cbc2a30a3ffd9b842e19c2cad62e9c3f303b
• Precompiled.zip SHA512: 21f5fd086ec68b180857a839fdf0edfb594f33c85ce3fd9bdf5ec9122ee5513244bb3dd2d6c20ba3f162705cf26e89a79033e7938c370c6b7393bfe5aff288c9
• Docs.zip SHA1: 9fe4d74a23106db59070d7c14498271390554c7f
• Docs.zip SHA512: e70d5b00176d02a1f51dd4da5a01b514d2318ecd8891e3ce8bba20b2651a690e3643df042dee33b0e6270ffbab999f859c1a2d8df984d897604a8c57629dac09

v1.9.1

1. Enhancements

Mix

• [mix format] Print relative paths in --check-formatted output
• [mix release] Support included applications

2. Bug fixes

Elixir

• [Code] Fix formatter wrongly removing nested parens in nested calls

Logger

• [Logger] Do not crash translator on poorly formatted supervisor names

Mix

• [mix compile] Raise readable error for mismatched sources during compilation
• [mix release] Preserve UTF8 encoding in release config files

Checksums

• Precompiled.zip SHA1: 51520d0edf924f3c4620739cf2009d545eab6e99
• Precompiled.zip SHA512: 14826fe295c19c9e331f2777f70a13ae55bf107ce043d0aeb747b5235de82bd6175c915f0bea63ffe0f87136357d76522c67bdd54fc61dd1f167afb4879a3845
• Docs.zip SHA1: ccaf7a52c586b9730d4cabe1482ec75c30676975
• Docs.zip SHA512: e0cfdfb2280d8696e534c627fd3b2f90a010cb6417a4e66b63663968335d82c01f30da8912932ebb6673fe726c059cd9e41a89e84cb49fe9868020e3eeddf04e

v1.9.0

Releases

The main feature in Elixir v1.9 is the addition of releases. A release is a self-contained directory that consists of your application code, all of its dependencies, plus the whole Erlang Virtual Machine (VM) and runtime. Once a release is assembled, it can be packaged and deployed to a target as long as the target runs on the same operating system (OS) distribution and version as the machine running the mix release command.

You can start a new project and assemble a release for it in three easy steps:

$ mix new my_app
$ cd my_app
$ MIX_ENV=prod mix release

A release will be assembled in _build/prod/rel/my_app. Inside the release, there will be a bin/my_app file which is the entry point to your system. It supports multiple commands, such as:

• bin/my_app start, bin/my_app start_iex, bin/my_app restart, and bin/my_app stop - for general management of the release

• bin/my_app rpc COMMAND and bin/my_app remote - for running commands on the running system or to connect to the running system

• bin/my_app eval COMMAND - to start a fresh system that runs a single command and then shuts down

• bin/my_app daemon and bin/my_app daemon_iex - to start the system as a daemon on Unix-like systems

• bin/my_app install - to install the system as a service on Windows machines

Why releases?

Releases allow developers to precompile and package all of their code and the runtime into a single unit. The benefits of releases are:

• Code preloading. The VM has two mechanisms for loading code: interactive and embedded. By default, it runs in the interactive mode which dynamically loads modules when they are used for the first time. The first time your application calls Enum.map/2, the VM will find the Enum module and load it. There’s a downside. When you start a new server in production, it may need to load many other modules, causing the first requests to have an unusual spike in response time. Releases run in embedded mode, which loads all available modules upfront, guaranteeing your system is ready to handle requests after booting.

• Configuration and customization. Releases give developers fine grained control over system configuration and the VM flags used to start the system.

• Self-contained. A release does not require the source code to be included in your production artifacts. All of the code is precompiled and packaged. Releases do not even require Erlang or Elixir in your servers, as they include the Erlang VM and its runtime by default. Furthermore, both Erlang and Elixir standard libraries are stripped to bring only the parts you are actually using.

• Multiple releases. You can assemble different releases with different configuration per application or even with different applications altogether.

Hooks and Configuration

Releases also provide built-in hooks for configuring almost every need of the production system:

• config/config.exs (and config/prod.exs) - provides build-time application configuration, which is executed when the release is assembled

• config/releases.exs - provides runtime application configuration. It is executed every time the release boots and is further extensible via config providers

• rel/vm.args.eex - a template file that is copied into every release and provides static configuration of the Erlang Virtual Machine and other runtime flags

• rel/env.sh.eex and rel/env.bat.eex - template files that are copied into every release and executed on every command to set up environment variables, including ones specific to the VM, and the general environment

We have written extensive documentation on releases, so we recommend checking it out for more information.

Configuration overhaul

A new Config module has been added to Elixir. The previous configuration API, Mix.Config, was part of the Mix build tool. But since releases provide runtime configuration and Mix is not included in releases, we ported the Mix.Config API to Elixir. In other words, use Mix.Config has been soft-deprecated in favor of import Config.

Another important change related to configuration is that mix new will no longer generate a config/config.exs file. Relying on configuration is undesired for most libraries and the generated config files pushed library authors in the wrong direction. Furthermore, mix new --umbrella will no longer generate a configuration for each child app, instead all configuration should be declared in the umbrella root. That's how it has always behaved, we are now making it explicit.

Other enhancements

There are many other enhancements. The Elixir CLI got a handful of new options in order to best support releases. Logger now computes its sync/async/discard thresholds in a decentralized fashion, reducing contention. EEx templates support more complex expressions than before. Finally, there is a new ~U sigil for working with UTC DateTimes as well as new functions in the File, Registry, and System modules.

v1.9.0 (2019-06-24)

1. Enhancements

EEx

• [EEx] Allow more complex mixed expressions when tokenizing

Elixir

• [Access] Allow Access.at/1 to handle negative index
• [CLI] Add support for --boot, --boot-var, --erl-config, --pipe-to, --rpc-eval, and --vm-args options
• [Code] Add static_atom_encoder option to Code.string_to_quoted/2
• [Code] Support :force_do_end_blocks on Code.format_string!/2 and Code.format_file!/2
• [Code] Do not raise on deadlocks on Code.ensure_compiled/1
• [Config] Add Config, Config.Reader, and Config.Provider modules for working with configuration
• [File] Add File.rename!/2
• [Inspect] Add :inspect_fun and :custom_options to Inspect.Opts
• [Kernel] Add ~U sigil for UTC date times
• [Kernel] Optimize &super/arity and &super(&1)
• [Kernel] Optimize generated code for with with a catch-all clause
• [Kernel] Validate __struct__ key in map returned by __struct__/0,1
• [Module] Add Module.get_attribute/3
• [Protocol] Improve Protocol.UndefinedError messages to also include the type that was attempted to dispatch on
• [Protocol] Optimize performance of dynamic dispatching for non-consolidated protocols
• [Record] Include field names in generated type for records
• [Regex] Automatically recompile regexes
• [Registry] Add Registry.select/2
• [System] Add System.restart/0, System.pid/0 and System.no_halt/1
• [System] Add System.get_env/2, System.fetch_env/1, and System.fetch_env!/1
• [System] Support SOURCE_DATE_EPOCH for reproducible builds

ExUnit

• [ExUnit] Allow multiple :exclude on configuration/CLI
• [ExUnit.DocTest] No longer wrap doctest errors in custom exceptions. They ended-up hiding more information than showing
• [ExUnit.DocTest] Display the actual doctest code when doctest fails

IEx

• [IEx.CLI] Copy ticktime from remote node on IEx --remsh
• [IEx.CLI] Automatically add a host on node given to --remsh

Logger

• [Logger] Use a decentralized mode computation for Logger which allows overloads to be detected more quickly
• [Logger] Use persistent_term to store configuration whenever available for performance

Mix

• [Mix] Follow XDG base dir specification in Mix for temporary and configuration files
• [Mix.Generator] Add copy_file/3, copy_template/4, and overwite?/2
• [Mix.Project] Add preferred_cli_target that works like preferred_cli_env
• [mix archive.uninstall] Allow mix archive.uninstall APP to uninstall any installed version of APP
• [mix new] No longer generate a config/ directory for mix new
• [mix release] Add support for releases
• [mix release.init] Add templates for release configuration
• [mix test] Allow running tests for a given umbrella app from the umbrella root with mix test apps/APP/test. Test failures also include the apps/APP prefix in the test location

2. Bug fixes

EEx

• [EEx] Consistently trim newlines when you have a single EEx expression per line on multiple lines

Elixir

• [Code] Quote :: in Code.format_string!/1 to avoid ambiguity
• [Code] Do not crash formatter on false positive sigils
• [Enum] Ensure the first equal entry is returned by Enum.min/2 and Enum.max/2
• [Kernel] Improve error message when string interpolation is used in a guard
• [Kernel] Properly merge and handle docs for callbacks with multiple clauses
• [Kernel] Guarantee reproducible builds on modules with dozens of specs
• [Kernel] Resolve __MODULE__ accordingly in nested defmodule to avoid double nesting
• [Kernel] Type variables starting with an underscore (_foo) should not raise compile error
• [Kernel] Keep order of elements when macro in/2 is expanded with a literal list on the right-hand side
• [Kernel] Print proper location on undefined function error from dynamically generated functions
• [System] Make sure :init.get_status/0 is set to {:started, :started} once the system starts
• [Path] Do not expand ~ in Path.expand/2 when not followed by a path separator
• [Protocol] Ensure debug_info is kept in protocols
• [Regex] Ensure inspect returns valid ~r// expressions when they are manually compiled with backslashes
• [Registry] Fix ETS leak in Registry.register/2 for already registered calls in unique registries while the process is still alive

ExUnit

• [ExUnit] Raise error if attempting to run single line tests on multiple files
• [ExUnit] Return proper error on duplicate child IDs on start_supervised

IEx

• [IEx] Automatically shut down IEx if we receive EOF

Logger

• [Logger] D...

v1.9.0-rc.0

Release v1.9.0-rc.0

v1.8.2

1. Bug fixes

EEx

• [EEx] Raise readable error message on bad EEx state

Elixir

• [Protocol] Ensure :debug_info is kept in protocols

Logger

• [Logger] Make sure Logger v1.8 does not get stuck in discard mode
• [Logger.Translator] Translate remote process crash in Logger

Checksums

• Precompiled.zip SHA1: 661dbf612c4b5fdb4390ff54121d82ff9452c3f3
• Precompiled.zip SHA512: f110669f99f8716e71f66b74d9604edabd1ed5b041e69962c01bae5274165e86ae95773d2e117ebf7f462fb68f3a2ae7891e50df372d676c2f1d975da59aa9e5
• Docs.zip SHA1: 9bafded1b743437938af8e29d63d06dea44ee96e
• Docs.zip SHA512: 409030abaaf1bcc87dbda850058f36a2f4e4b29ef7c086c130b1619f3d44c79276b8ec42796fb9723704a948db1f828146dc85aa15477029e3cceeb6d6007163

v1.8.1

1. Bug fixes

Elixir

• [Float] Fix rounding for subnormal floats

IEx

• [IEx] Fix IEx.pry crash when IEx isn't running
• [IEx.CLI] Add IEx warning when using --remsh with "dumb" terminal
• [IEx.Helpers] Sort results by arity on h helper

Mix

• [mix compile] Do not include optional dependencies in extra applications as it is incompatible with shared deps in umbrellas

Checksums

• Precompiled.zip SHA1: 9b9a15b299b15c78ec9c1c92cdcf293905290d09
• Precompiled.zip SHA512: 17c2d07eb4bc259031e7b9f1449bc2a16745a6fb1f3685ed5153da624f87fe49cc61b304a0cb531cbda3407f041b517e2b508cf0b3aa9a998e23598c301c7886
• Docs.zip SHA1: 6b98c75d8e905c849898b708b60e3449ba0c5291
• Docs.zip SHA512: d3f9bc4821c0d1c284b3e233d2f46c7eb6a3173d5a58d1066078ae62a9cf06c3235d0073715083fc67dda279603a9ea4fbe937d042c321fdec56531588dd0c9a