Release v1.3.0

Signed-off-by: José Valim <jose.valim@plataformatec.com.br>

.appveyor.yml

@@ -1,18 +0,0 @@
-version: 1-{branch}+{build}
-
-build_script:
-  - cmd: C:\MinGW\msys\1.0\bin\make
-  - cmd: rmdir /s /q .git
-before_test:
-  - cmd: set PATH=%PATH%;C:\Program Files\erl8.3\erts-8.3\bin
-test_script:
-  - cmd: C:\MinGW\msys\1.0\bin\make --keep-going test_windows
-
-environment:
-  ELIXIR_ASSERT_TIMEOUT: 2000
-
-matrix:
-  allow_failures:
-    - platform: x86
-    - platform: x64
-    - platform: Any CPU

.formatter.exs

@@ -1,17 +0,0 @@
-[
-  inputs: [
-    "lib/*/{lib,unicode,test}/**/*.{ex,exs}",
-    "lib/*/mix.exs"
-  ],
-
-  locals_without_parens: [
-    # Formatter tests
-    assert_format: 2,
-    assert_format: 3,
-    assert_same: 1,
-    assert_same: 2,
-
-    # Errors tests
-    assert_eval_raise: 3
-  ]
-]

.gitignore

@@ -1,13 +1,17 @@
-/doc/
-/lib/*/ebin/
-/lib/*/_build/
-/lib/*/tmp/
+/doc
+/ebin
+/lib/*/ebin/*
+/lib/*/tmp
+/lib/elixir/src/*_lexer.erl
 /lib/elixir/src/*_parser.erl
-/lib/elixir/test/ebin/
+/lib/elixir/src/elixir.app.src
+/lib/elixir/test/ebin
 /man/elixir.1
 /man/iex.1
+/rel/elixir
 /Docs-v*.zip
 /Precompiled-v*.zip
 /.eunit
+/.release
 .elixir.plt
 erl_crash.dump

.travis.yml

@@ -1,44 +1,15 @@
-language: bash
+language: erlang
+
+otp_release:
+  - 18.0
+
 sudo: false
 
-env:
-  global:
-    - ELIXIR_ASSERT_TIMEOUT=2000
-  matrix:
-    - OTP_RELEASE=OTP-19.0
-    - OTP_RELEASE=OTP-19.1
-    - OTP_RELEASE=OTP-19.2
-    - OTP_RELEASE=OTP-19.3
-    - OTP_RELEASE=OTP-20.0
-    - OTP_RELEASE=OTP-20.1
-    - OTP_RELEASE=OTP-20.2
-    - OTP_RELEASE=OTP-20.3
-    - OTP_RELEASE=OTP-21.0
-    - OTP_RELEASE=maint
-    - OTP_RELEASE=master
-
-matrix:
-  fast_finish: true
-  allow_failures:
-    - env: OTP_RELEASE=maint
-    - env: OTP_RELEASE=master
-
-install:
-  - wget -O otp.tar.gz https://repo.hex.pm/builds/otp/ubuntu-14.04/${OTP_RELEASE}.tar.gz
-  - mkdir -p otp
-  - tar zxf otp.tar.gz -C otp --strip-components=1
-  - otp/Install -minimal $(pwd)/otp
-  - PATH=$(pwd)/otp/bin:$PATH
-
-script:
-  - make compile
-  - rm -rf .git
-  - make test
-  - dialyzer -pa lib/elixir/ebin --build_plt --output_plt elixir.plt --apps lib/elixir/ebin/elixir.beam lib/elixir/ebin/Elixir.Kernel.beam
+script: "make compile && rm -rf .git && make test"
 
 notifications:
+  irc: "irc.freenode.org#elixir-lang"
   recipients:
-    - jose.valim@gmail.com
+    - jose.valim@plataformatec.com.br
     - eric.meadows.jonsson@gmail.com
-    - lexmag@me.com
-    - an.leopardi@gmail.com
+

CHANGELOG.md

@@ -1,310 +1,405 @@
-# Changelog for Elixir v1.7
+# Changelog for Elixir v1.3
 
-Elixir v1.7 is the last release to support Erlang/OTP 19. We recommend everyone to migrate to Erlang/OTP 20+.
+Elixir v1.3 brings many improvements to the language, the compiler and its tooling, specially Mix (Elixir's build tool) and ExUnit (Elixir's test framework).
 
-## Documentation metadata
+## Language improvements
 
-Elixir v1.7 implements [EEP 48](http://erlang.org/eep/eeps/eep-0048.html). EEP 48 aims to bring documentation interoperability across all languages running on the Erlang VM. The documentation format proposed by EEP 48 also supports metadata, which is now fully exposed to Elixir developers:
+The language has been improved semantically and includes new types and APIs. Let's see the three major features.
+
+### Deprecation of imperative assignment
+
+Elixir will now warn if constructs like `if`, `case` and friends assign to a variable that is accessed in an outer scope. As an example, imagine a function called `format` that receives a message and some options and it must return a path alongside the message:
 
 ```elixir
-@moduledoc "A brand new module"
-@moduledoc authors: ["Jane", "Mary"], since: "1.4.0"
-```
+def format(message, opts) do
+  path =
+    if (file = opts[:file]) && (line = opts[:line]) do
+      relative = Path.relative_to_cwd(file)
+      message  = Exception.format_file_line(relative, line) <> " " <> message
+      relative
+    end
 
-Passing metadata is supported on `@doc`, `@moduledoc` and `@typedoc`.
-
-To access the new documentation format, developers should use `Code.fetch_docs/1`. The old documentation format is no longer available and the old `Code.get_docs/2` function will return `nil` accordingly.
-
-Tools like IEx and ExDoc have been updated to leverage the new format and show relevant metadata to users. While Elixir allows any metadata to be given, those tools currently exhibit only `:deprecated` and `:since`. Other keys may be shown in the future.
-
-## The `__STACKTRACE__` construct
-
-Erlang/OTP 21.0 introduces a new way to retrieve the stacktrace that is lexically scoped and no longer relies on side-effects like `System.stacktrace/0` does. Before one would write:
-
-```elixir
-try do
-  ... something that may fail ...
-rescue
-  e ->
-    log(e, System.stacktrace())
-    reraise(e, System.stacktrace())
+  {path, message}
 end
 ```
 
-In Elixir v1.7, this can be written as:
+The `if` block above is implicitly changing the value in `message`. Now imagine we want to move the `if` block to its own function to clean up the implementation:
 
 ```elixir
-try do
-  ... something that may fail ...
-rescue
-  e ->
-    log(e, __STACKTRACE__)
-    reraise(e, __STACKTRACE__)
+def format(message, opts) do
+  path = with_file_and_line(message, opts)
+  {path, message}
+end
+
+defp with_file_and_line(message, opts) do
+  if (file = opts[:file]) && (line = opts[:line]) do
+    relative = Path.relative_to_cwd(file)
+    message  = Exception.format_file_line(relative, line) <> " " <> message
+    relative
+  end
 end
 ```
 
-This change may also yield performance improvements in the future, since the lexical scope allows us to track precisely when a stacktrace is used and we no longer need to keep references to stacktrace entries after the `try` construct finishes.
+The refactored version is broken because the `if` block was actually returning two values, the relative path *and* the new message. Elixir v1.3 will warn on such cases, forcing both variables to be explicitly returned from `if`, `case` and other constructs. Furthermore, this change gives us the opportunity to unify the language scoping rules in future releases.
 
-Other parts of the exception system have been improved. For example, more information is provided in certain occurrences of `ArgumentError`, `ArithmeticError` and `KeyError` messages.
+### Calendar types and sigils
 
-## Erlang/OTP logger integration
+Elixir v1.3 introduces the `Calendar` module as well as 4 new calendar types:
 
-Erlang/OTP 21 includes a new `:logger` module. Elixir v1.7 fully integrates with the new `:logger` and leverages its metadata system. The `Logger.Translator` mechanism has also been improved to export metadata, allowing custom Logger backends to leverage information such as:
+  * `Date` - used to store dates (year, month, day) in a given calendar
+  * `Time` - used to store time (hour, minute, second, microseconds)
+  * `NaiveDateTime` - used to store datetimes without a timezone (year, month, day, hour, minute, second, microseconds) in a given calendar. It is called naïve because without a timezone, the datetime may not actually exist. For example, when there are daylight savings changes, a whole hour may not exist (when the clock moves forward) or a particular instant may happen twice (when the clock moves backwards)
+  * `DateTime` - used to store datetimes with timezone (year, month, day, hour, minute, second, microsecond and time zone, with abbreviation, UTC and standard offset)
 
-  * `:crash_reason` - a two-element tuple with the throw/error/exit reason as first argument and the stacktrace as second
+The current Calendar modules and its types is to provide a base for interoperatibility in the ecosystem instead of full-featured datetime API. This release includes basic functionality for building new types and converting them from and back strings.
 
-  * `:initial_call` - the initial call that started the process
+Elixir v1.3 also introduces 3 new sigils related to the types above:
 
-  * `:registered_name` - the process registered name as an atom
+  * `~D[2016-05-29]` - builds a new date
+  * `~T[08:00:00]` and `~T[08:00:00.285]` - builds a new time (with different precisions)
+  * `~N[2016-05-29 08:00:00]` - builds a naive date time
 
-We recommend Elixir libraries that previously hooked into Erlang's `:error_logger` to hook into `Logger` instead, in order to support all current and future Erlang/OTP versions.
+### Access selectors
 
-## Other Logger improvements
+This release introduces new accessors to make it simpler for developers to traverse nested data structures, traversing and updating data in different ways.  For instance, given a user with a list of languages, here is how to deeply traverse the map and convert all language names to uppercase:
 
-Previously, Logger macros such as `debug`, `info`, and so on would always evaluate their arguments, even when nothing would be logged. From Elixir v1.7, the arguments are only evaluated when the message is logged.
+```iex
+iex> user = %{name: "john",
+...>          languages: [%{name: "elixir", type: :functional},
+...>                      %{name: "c", type: :procedural}]}
+iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
+%{name: "john",
+  languages: [%{name: "ELIXIR", type: :functional},
+              %{name: "C", type: :procedural}]}
+```
 
-The Logger configuration system also accepts a new option called `:compile_time_purge_matching` that allows you to remove log calls with specific compile-time metadata. For example, to remove all logger calls from application `:foo` with level lower than `:info`, as well as remove all logger calls from `Bar.foo/3`, you can use the following configuration:
+You can see the new accessors in the `Access` module.
+
+## Mix
+
+Mix includes new tasks to improve your everyday workflow. Some of those tasks relies on many compiler improvements to know more about your code, providing static analysis to find possible bugs in your code and faster compilation cycles.
+
+### Compiling n files
+
+Mix no longer announces every file it compiles. Instead it outputs how many files there is to compile per compilers. Here is the output for a project like [`gettext`](https://github.com/elixir-lang/gettext):
+
+```
+Compiling 1 file (.yrl)
+Compiling 1 file (.erl)
+Compiling 19 files (.ex)
+Generated gettext app
+```
+
+In case a file is taking too long to compile, Mix will announce such, for example:
+
+```
+Compiling lib/gettext.ex (it's taking more than 5s)
+```
+
+The goal of these changes is to put an increased focus on the "warnings" emitted by the compiler.
+
+In any case, the previous behaviour can be brought back with the `--verbose` flag and the compilation threshold for files that are taking long can be set via the `--long-compilation-threshold` option.
+
+### mix xref
+
+Speaking about warnings, Mix v1.3 includes a new task called `xref` that performs cross reference checks in your code. One of such checks is the ability to find calls to modules and functions that do not exist. For example, if in your library code you call `ThisModuleDoesNotExist.foo(1, 2, 3)`, `mix xref unreachable` will be able to find such code and let you know about it.
+
+Since such checks can discover possible bugs in your codebase, a new compiler called `xref` has been added to `Mix.compilers/0`, so they run by default every time you compile your code.
+
+We have included other modes in `xref`, such as `mix xref callers Foo`, to find all places in your code that a function from the module `Foo` is called. We hope other tools and text editors can leverage such features to provide useful functionality for their users.
+
+### Better dependency tracking
+
+Besides `xref`, Elixir v1.3 provides better module tracking generally. For example, in previous versions, if you changed a `:path` dependency, Elixir would always fully recompile the current project. In this release, we have improved the tracking algorithms such that, if you change a `:path` dependency, only the files that depend on such dependency are recompiled.
+
+Such improvements do not only make compilation faster but they also make working with umbrella applications much more productive. Previously, changing a sibling application triggered a full project recompilation, now Elixir can track between sibling applications and recompile only what is needed.
+
+### mix app.tree and deps.tree
+
+Mix also includes both `mix app.tree` and `mix deps.tree`. The first will list all applications your current project needs to start in order to boot (i.e. the ones listed in `application/0` in your `mix.exs`) while the second will lists all of your dependencies and so on recursively.
+
+Here is a quick example from [Plug](https://github.com/elixir-lang/plug):
 
 ```elixir
-config :logger,
-  compile_time_purge_matching: [
-    [application: :foo, level_lower_than: :info],
-    [module: Bar, function: "foo/3"]
-  ]
+$ mix app.tree
+plug
+├── elixir
+├── crypto
+├── logger
+│   └── elixir
+└── mime
+    └── elixir
 ```
 
-## ExUnit improvements
+### mix escript.install
 
-ExUnit has also seen its own share of improvements. Assertions such as `assert some_fun(arg1, arg2, arg3)` will now include the value of each argument in the failure report:
+Mix also includes `mix escript.install` and `mix escript.uninstall` tasks for managing escripts. The tasks was designed in a way to mimic the existing `mix archive` functionality except that:
+
+  * Archives must be used sparingly because every new archive installed affects Mix performance, as every new archive is loaded when Mix boots. Escripts solve this by being managed apart from your Elixir/Mix installed
+  * Archives depends on the current Elixir version. Therefore, updating your Elixir version may break an archive. Fortunately, escripts include Elixir inside themselves, and therefore do not depend on your Elixir system version
+
+Escripts will be installed at `~/.mix/escripts` which must be added to your [`PATH` environment variable](https://en.wikipedia.org/wiki/PATH_(variable)).
+
+### Option parser integration
+
+Elixir v1.3 includes improvements to the option parser, including `OptionParser.parse!/2` and `OptionParser.parse_head!/2` functions that will raise in case of invalid or unknown switches. Mix builds on top of this functionality to provide automatic error reporting solving a common complaint where invalid options were not reported by Mix tasks.
+
+For example, invoking `mix test --unknown` in earlier Elixir versions would silently discard the `--unknown` option. Now `mix test` correctly reports such errors:
 
 ```
-  1) test function call arguments (TestOneOfEach)
-     lib/ex_unit/examples/one_of_each.exs:157
-     Expected truthy, got false
-     code: assert some_vars(1 + 2, 3 + 4)
-     arguments:
+$ mix test --unknown
+** (Mix) Could not invoke task "test": 1 error found!
+--unknown : Unknown option
+```
 
-         # 1
-         3
+Note not all tasks have been updated to use strict option parsing. Some tasks, like `mix compile`, are actually a front-end to many other tasks, and as such, it cannot effectively assert which options are valid.
 
-         # 2
-         7
+## ExUnit
 
+ExUnit packs many improvements on the tooling side, better integration with external tools, as well as mechanisms to improve the readability of your tests.
+
+### mix test --stale
+
+ExUnit builds on top of `mix xref` to provide the `mix test --stale` functionality. When the `--stale` flag is given, `mix` will only run the tests that may have changed since the last time you ran `mix test --stale`. For example:
+
+  * If you saved a test file on disk, Mix will run that file and ignore the ones that have not changed
+  * If you changed a library file, for example, `lib/foo.ex` that defines `Foo`, any test that invokes a function in `Foo` directly or indirectly will also run
+  * If you modify your `mix.exs` or your `test/test_helper.exs`, Mix will run the whole test suite
+
+This feature provides a great workflow for developers, allowing them to effortlessly focus on parts of the codebase when developing new features.
+
+### Diffing
+
+ExUnit will now include diff-ing output every time a developer asserts `assert left == right` in their tests. For example, the assertion:
+
+```elixir
+assert "fox jumps over the lazy dog" ==
+       "brown fox jumps over the dog"
+```
+
+will fail with
+
+```elixir
+  1) test compare (Difference)
+     lib/ex_unit/examples/difference.exs:10
+     Assertion with == failed
+     lhs:  "fox jumps over the lazy dog"
+     rhs:  "brown fox jumps over the dog"
      stacktrace:
-       lib/ex_unit/examples/one_of_each.exs:158: (test)
+       lib/ex_unit/examples/difference.exs:11: (test)
 ```
 
-Furthermore, failures in doctests are now colored and diffed.
+in a way that "lazy" in "lhs" will be shown in red to denote it has been removed from "rhs" while "brown" in "rhs" will be shown in green to denote it has been added to the "rhs".
 
-On the `mix test` side of things, there is a new `--failed` flag that runs all tests that failed the last time they ran. Finally, coverage reports generated with `mix test --cover` include a summary out of the box:
+When working with large or nested data structures, the diffing algorithm makes it fast and convenient to spot the actual differences in the asserted values.
 
-```
-Generating cover results ...
+### Test types
 
-Percentage | Module
------------|--------------------------
-   100.00% | Plug.Exception.Any
-   100.00% | Plug.Adapters.Cowboy2.Stream
-   100.00% | Collectable.Plug.Conn
-   100.00% | Plug.Crypto.KeyGenerator
-   100.00% | Plug.Parsers
-   100.00% | Plug.Head
-   100.00% | Plug.Router.Utils
-   100.00% | Plug.RequestId
-       ... | ...
------------|--------------------------
-    77.19% | Total
+ExUnit v1.3 includes the ability to register different test types. This means libraries like QuickCheck can now provide functionality such as:
+
+```elixir
+defmodule StringTest do
+  use ExUnit.Case, async: true
+  use PropertyTestingLibrary
+
+  property "starts_with?" do
+    forall({s1, s2} <- {utf8, utf8}) do
+      String.starts_with?(s1 <> s2, s1)
+    end
+  end
+end
 ```
 
-## v1.7.4 (2018-10-24)
+At the end of the run, ExUnit will also report it as a property, including both the amount of tests and properties:
+
+```
+1 property, 10 tests, 0 failures
+```
+
+### Named setups and describes
+
+Finally, ExUnit v1.3 includes the ability to organize tests together in describe blocks:
+
+```elixir
+defmodule StringTest do
+  use ExUnit.Case, async: true
+
+  describe "String.capitalize/2" do
+    test "uppercases the first grapheme" do
+      assert "T" <> _ = String.capitalize("test")
+    end
+
+    test "lowercases the remaining graphemes" do
+      assert "Test" = String.capitalize("TEST")
+    end
+  end
+end
+```
+
+Every test inside a describe block will be tagged with the describe block name. This allows developers to run tests that belong to particular blocks, be them in the same file or across many files:
+
+```
+$ mix test --only describe:"String.capitalize/2"
+```
+
+Note describe blocks cannot be nested. Instead of relying on hierarchy for composition, we want developers to build on top of named setups. For example:
+
+```elixir
+defmodule UserManagementTest do
+  use ExUnit.Case, async: true
+
+  describe "when user is logged in and is an admin" do
+    setup [:log_user_in, :set_type_to_admin]
+
+    test ...
+  end
+
+  describe "when user is logged in and is a manager" do
+    setup [:log_user_in, :set_type_to_manager]
+
+    test ...
+  end
+
+  defp log_user_in(context) do
+    # ...
+  end
+end
+```
+
+By restricting hierarchies in favor of named setups, it is straight-forward for the developer to glance at each describe block and know exactly the setup steps involved.
+
+## v1.3.0 (2016-06-21)
 
 ### 1. Enhancements
 
-#### Elixir
+#### EEx
 
-  * [Kernel] Expand `left..right` at compile time in more cases, which leads to improved performance under different scenarios, especially on `x in left..right` expressions
-
-#### Mix
-
-  * [mix deps.loadpaths] Add `--no-load-deps` flag. This is useful for Rebar 3 compatibility
-
-### 2. Bug fixes
+  * [EEx.Engine] Support an `init/1` function in engines that will return the initial buffer (defaults to an empty string)
 
 #### Elixir
 
-  * [Calendar] Fix for converting from negative iso days on New Year in a leap year
-  * [Kernel] Ensure `@spec`, `@callback`, `@type` and friends can be read accordingly
-  * [Module] Avoid warnings when using Module.eval_quoted in the middle of existing definitions
-
-#### Mix
-
-  * [mix archive.build] Unload previous archive versions before building
-  * [mix format] Expand paths so mix format `path\for\windows.ex` works
-  * [mix test] Ensure that `--cover` displays correct coverage in an umbrella app
-
-## v1.7.3 (2018-08-24)
-
-### 1. Bug fixes
+  * [Access] Add support for `Access.all/0`, `Access.elem/1`, `Access.key/2` and `Access.key!/1` for traversing nested data structures
+  * [Calendar] Add `Calendar` and `Date`, `Time`, `NaiveDateTime` and `DateTime` types
+  * [CLI] Add `--logger-otp-reports BOOL` and `--logger-sasl-reports BOOL` switches
+  * [Compiler] Emit a summary of compilation errors when modules are missing
+  * [Enum] Add `Enum.group_by/3` that allows developers to map on the value being grouped
+  * [Enum] Make list values in maps returned by `Enum.group_by/2` and `Enum.group_by/3` preserve the order of the input enumerable instead of reversing it.
+  * [Enum] Add `Enum.drop_every/2` that drops every `nth`, including the first one
+  * [Exception] Suggest possible functions on `UndefinedFunctionError` for existing modules
+  * [Exception] Warn if unknown fields are given to `raise/2`
+  * [File] Support IO devices in `File.copy/3`
+  * [GenServer] Raise a more meaningful exit if you try to `GenServer.call/3` yourself
+  * [Inspect] Support `:base` option when inspecting binaries
+  * [IO] Add `IO.warn/2` that will print a warning message with stacktrace and notify the compiler a warning was printed (in case --warnings-as-errors was enabled)
+  * [Kernel] Support `generated: true` in quote
+  * [Kernel] Support `Kernel.pop_in/1` and `Kernel.pop_in/2` for yanking a value from a nested data structure
+  * [Kernel] Allow variable struct names when matching, for example, `%module{key: "value"} = struct`
+  * [Kernel] Allow guards on the left side of `<-` in `for` and `with` special forms
+  * [Kernel] Support `else` chunks in `with`
+  * [Kernel] Track `{module, function, arity}` imports and warn on unused ones when such are specified in `:only`
+  * [Kernel] Add `keyword/0` and `keyword/1` built-in types to typespecs
+  * [Kernel] Add sigils for date (`~D[2015-04-17]`), time (`~T[08:00:00]`) and naive date times `~N[2015-04-17 08:00:00]`
+  * [Kernel] Support `@enforce_keys` on `defstruct/1` to guarantee some keys are explicitly given when building structs
+  * [OptionParser] Add support for `:count` switch type
+  * [OptionParser] Add `parse!/2` and `parse_head!/2` that raise `OptionParser.ParseError` in case of errors
+  * [Process] Add `Process.sleep/1`
+  * [Range] `Range.range?/1` now checks the validity of a range.
+  * [Regex] Support `:include_captures` in `Regex.split/3`
+  * [String] Add `String.myers_difference/2` for calculating the difference between two strings
+  * [System] Add `System.os_time/0` and `System.os_time/1`
+  * [Typespec] Add support for `%{required(foo) => bar}` and `%{optional(foo) => bar}` forms (Erlang 19 only)
+  * [Typespec] Add support for `@optional_callbacks` to mark certain that certain callbacks may be optionally implemented
+  * [Typespec] Introduce `%{...}` to mean any map (Erlang 19 only)
+  * [URI] Add `URI.merge/2`
+  * [Version] Add `Version.parse!/1`
 
 #### ExUnit
 
-  * [ExUnit.Assertions] Do not attempt to expand `try/1` as it is a special form
-
-#### Mix
-
-  * [mix compile.app] Do not include applications with `runtime: false` as a runtime dependency for applications coming from Hex
-
-## v1.7.2 (2018-08-05)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [DateTime] Take negative years into account in `DateTime.from_iso8601/1`
-  * [Kernel] Do not emit warnings for repeated docs over different clauses due to false positives
-
-#### Mix
-
-  * [mix compile] Properly mark top-level dependencies as optional and as runtime. This fixes a bug where Mix attempted to start optional dependencies of a package when those optional dependencies were not available
-  * [mix compile] Avoid deadlock when a config has a timestamp later than current time
-  * [mix help] Show task and alias help when both are available
-  * [mix test] Do not fail suite if there are no test files
-
-## v1.7.1 (2018-07-26)
-
-### 1. Bug fixes
-
-#### Elixir
-
-  * [Calendar] Work-around a Dialyzer bug that causes it to loop for a long time, potentially indefinitely
-
-## v1.7.0 (2018-07-25)
-
-### 1. Enhancements
-
-#### Elixir
-
-  * [Calendar.ISO] Support negative dates in `Calendar.ISO`
-  * [Calendar] Add `Calendar.months_in_year/1` callback
-  * [Code] Add `Code.compile_file/2` that compiles files without leaving footprints on the system
-  * [Code] Add `Code.purge_compiler_modules/0` that purges any compiler module left behind. This is useful for live systems dynamically compiling code
-  * [Code] Add `Code.fetch_docs/1` that returns docs in the [EEP 48](http://erlang.org/eep/eeps/eep-0048.html) format
-  * [Date] Add `Date.months_in_year/1` function
-  * [DynamicSupervisor] Use the name of the `DynamicSupervisor` as the ID whenever possible
-  * [Exception] Provide "did you mean" suggestions on KeyError
-  * [Exception] Provide more information on ArithmeticError on Erlang/OTP 21+
-  * [Function] Add `Function` module with `capture/3`, `info/1` and `info/2` functions
-  * [GenServer] Support the new `handle_continue/2` callback on Erlang/OTP 21+
-  * [IO.ANSI] Add cursor movement to `IO.ANSI`
-  * [Kernel] Support adding arbitrary documentation metadata by passing a keyword list to `@doc`, `@moduledoc` and `@typedoc`
-  * [Kernel] Introduce `__STACKTRACE__` to retrieve the current stacktrace inside `catch`/`rescue` (this will be a requirement for Erlang/OTP 21+)
-  * [Kernel] Raise on unsafe variables in order to allow us to better track unused variables
-  * [Kernel] Warn when using `length` to check if a list is not empty on guards
-  * [Kernel] Add hints on mismatched `do`/`end` and others pairs
-  * [Kernel] Warn when comparing structs using the `>`, `<`, `>=` and `<=` operators
-  * [Kernel] Warn on unsupported nested comparisons such as `x < y < z`
-  * [Kernel] Warn if redefining documentation across clauses of the same definition
-  * [Kernel] Warn on unnecessary quotes around atoms, keywords and calls
-  * [Macro] Add `Macro.special_form?/2` and `Macro.operator?/2` that returns `true` if the given name/arity is a special form or operator respectively
-  * [Macro.Env] Add `Macro.Env.vars/1` and `Macro.Env.has_var?/2` that gives access to environment data without accessing private fields
-  * [Regex] Include endianness in the regex version. This allows regexes to be recompiled when an archive is installed in a system with a different endianness
-  * [Registry] Add `Registry.count/1` and `Registry.count_match/4`
-  * [String] Update to Unicode 11
-  * [StringIO] Add `StringIO.open/3`
-  * [System] Use ISO 8601 in `System.build_info/0`
-
-#### ExUnit
-
-  * [ExUnit.Assertion] Print the arguments in error reports when asserting on a function call. For example, if `assert is_list(arg)` fails, the argument will be shown in the report
-  * [ExUnit.Diff] Improve diffing of lists when one list is a subset of the other
-  * [ExUnit.DocTest] Show colored diffs on failed doctests
-  * [ExUnit.Formatter] Excluded tests, via the `--exclude` and `--only` flags, are now shown as "Excluded" in reports. Tests skipped via `@tag :skip` are now exclusively shown as "Skipped" and in yellow
+  * [ExUnit] Show pinned variables on failed `assert ^left = right` and `assert match?(^left, right)` assertions
+  * [ExUnit] Add `ExUnit.Case.register_attribute` which allow attributes to be cleaned up whenever a test is defined
+  * [ExUnit] Add `ExUnit.Case.register_test` and support the ability to tag "tests" by type. This will allow projects like QuickCheck to change the wording in formatters to say "10 properties" instead of "10 tests"
+  * [ExUnit] Support diffing of values when using `==` in `assert`
+  * [ExUnit] Start running tests as soon as cases are loaded. This feature is enabled by default when running tests through Mix
+  * [ExUnit] Raise a straight-forward error message in case a duplicate test name is defined
+  * [ExUnit] Bump the default number of max cases to double of schedulers to support both IO and CPU bound tests
+  * [ExUnit] Support for named setups in `setup` and `setup_all`
+  * [ExUnit] Support for bundling tests together with `describe/2`
 
 #### IEx
 
-  * [IEx.Helpers] Add `use_if_available/2`
-  * [IEx.Helpers] Allow `force: true` option in `recompile/1`
-  * [IEx.Helpers] Add `:allocators` pane to `runtime_info/1`
-  * [IEx.Helpers] Show documentation metadata in `h/1` helpers
+  * [IEx] Add `nl/2` that loads a given module on a list of nodes
+  * [IEx.Helpers] No longer restart applications on `recompile/1`
+  * [IEx.Autocomplete] Improve IEx expand to handle functions after `&`
 
 #### Logger
 
-  * [Logger] Ensure nil metadata is always pruned
-  * [Logger] Only evaluate Logger macro arguments when the message will be logged
-  * [Logger] Add `:compile_time_purge_matching` to purge logger calls that match certain compile time metadata, such as module names and application names
-  * [Logger] Log to `:stderr` if a backend fails and there are no other backends
-  * [Logger] Allow translators to return custom metadata
-  * [Logger] Return `:crash_reason`, `:initial_call` and `:registered_name` as metadata in crash reports coming from Erlang/OTP
+  * [Logger] Introduce `Logger.reset_metadata/0,1`
 
 #### Mix
 
-  * [mix archive.install] Add support for the Hex organization via `--organization`
-  * [mix archive.uninstall] Support `--force` flag
-  * [mix compile] Improve support for external build tools such as `rebar`
-  * [mix deps] Include `override: true` in rebar dependencies to make the behaviour closer to how rebar3 works (although diverged deps are still marked as diverged)
-  * [mix escript.install] Add support for the Hex organization via `--organization`
-  * [mix escript.uninstall] Support `--force` flag
-  * [mix help] Also list aliases
-  * [mix local] Use ipv6 with auto fallback to ipv4 when downloading data
-  * [mix profile] Allow all profiling tasks to run programatically
-  * [mix test] Add `--failed` option that only runs previously failed tests
-  * [mix test] Print coverage summary by default when the `--cover` flag is given
-  * [Mix.Project] Add `Mix.Project.clear_deps_cache/0`
-  * [Mix.Project] Add `Mix.Project.config_mtime/0` that caches the config mtime values to avoid filesystem access
+  * [Mix] Add `mix xref` and `mix compile.xref` that runs cross-reference checks, with the latter running after compilation by default
+  * [Mix] Add `mix app.tree` and `mix deps.tree`
+  * [Mix] Add `Mix.Task.rerun/2` that reenables and re-runs a task
+  * [Mix] Integrate `OptionParser.ParseError` into Mix, automatically converting such exceptions into `Mix.Error` and embedding the task information
+  * [Mix] Support `@preferred_cli_env` attribute when defining tasks
+  * [Mix] Support `mix test --raise` that will raise when a test suite fails (instead of setting the exit code to 1)
+  * [Mix] Enable rebar3 manager by default for Hex dependencies
+  * [Mix] Add `mix escript.install` to install escripts
+  * [Mix] Print stacktraces for `Mix.Error` when `MIX_DEBUG=1` is set
+  * [Mix] Add a user friendly error for merge conflicts on `mix.lock`
+  * [Mix] Track files between path dependencies. This means umbrella applications will no longer trigger full recompilation when a sibling changes. Instead it will only recompile the files affected by the sibling changes
+  * [Mix] No longer print every file being compiled. Instead a generic "Compiling N files (.ext)" will be printed and files will only be logged in case they take more than 5 seconds to compile. This threshold can be customized by passing the `--long-compilation-threshold` flag and the previous behaviour can be reenabled by giving `--verbose` to `mix compile`
+  * [Mix] Add `mix test --stale` that uses static analysis on source files to know which tests should run when source files changes. If any test file changes, it will also re-run. Changing a configuration file or the test helper will trigger a full recompilation
 
 ### 2. Bug fixes
 
 #### Elixir
 
-  * [IO.ANSI.Docs] Fix table column alignment when converting docs to ANSI escapes
-  * [Code] Ensure `string_to_quoted` returns error tuples instead of raising in certain constructs
-  * [Code.Formatter] Consistently format keyword lists in function calls with and without parens
-  * [Code.Formatter] Do not break after `->` when there are only comments and one-line clauses
-  * [File] Allow the `:trim_bom` option to be used with `:encoding`
-  * [Kernel] Raise on unsafe variables as some of the code emitted with unsafe variables would not correctly propagate variables or would disable tail call optimization semantics
-  * [Kernel] Do not crash on dynamic sizes in binary generators with collectable into in comprehensions
-  * [Kernel] Do not crash on literals with non-unary size in binary generators with collectable into in comprehensions
-  * [Task] Improve error reports and exit reasons for failed tasks on Erlang/OTP 20+
-
-#### ExUnit
-
-  * [ExUnit.Case] Raise proper error if `@tag` and `@moduletag` are used before `use ExUnit.Case`
-  * [ExUnit.Case] Raise proper error if `@describetag` is used outside of `describe/2` blocks
-  * [ExUnit.DocTest] Emit proper assertion error on doctests with invalid UTF-8
+  * [Application] Ensure `Application.spec/2` returns nil for unknown applications
+  * [GenServer] Ensures `cast/2` returns `:ok` if locally registered process is not found
+  * [Inspect] Ensure binaries break into new lines when inspected
+  * [Kernel] Do not choke on capture operator with argument above `&191`
+  * [Kernel] Raise if `defstruct` is called multiple times
+  * [Kernel] Ensure `Module.create/3` respects var/alias hygiene
+  * [Kernel] Support non-literal ranges on the right side of `in/2`
+  * [Macro] Fix `Macro.to_string/1` on a call of a capture argument, for example `&(&1).(:x)`
+  * [OptionParser] Allow `OptionParser` to parse negative numbers
+  * [Record] Fix `Record.is_record/2` when dealing with non-record tuples
+  * [String] Ensure `strip` also removes non-breaking whitespaces (and ensure `split` still does not split on them)
+  * [URI] Use square brackets for IPv6 in `URI.to_string/1`
 
 #### Mix
 
-  * [mix archive.install] Fetch optional dependencies when installing an archive from Git/Hex
-  * [mix compile] Properly track config files in umbrella projects and recompile when any relevant umbrella configuration changes
-  * [mix deps] Ensure the same dependency from different SCMs are tagged as diverged when those SCMs are remote and non-remote
-  * [mix deps] Ensure we re-run dependency resolution when overriding a skipped dep in umbrella
-  * [mix deps.compile] Perform clean builds for dependencies on outdated locks to avoid old modules from affecting future compilation
-  * [mix escript.install] Fetch optional dependencies when installing an escript from Git/Hex
+  * [Mix] Improve task not found message when Mix would include the not found task as a suggestion due to different casing
+  * [Mix] Ignore lock revision when the lock is out of date when updating Mix dependencies. Before this fix, Git tags and branches in the lock file would erroneously take higher precedence than the one in `mix.exs`
+  * [Mix] Only recompile empty Elixir files if they change instead of recompiling them on every run
+  * [Mix] Ensure .app file is written in UTF-8 (this allows app descriptions to contain UTF-8 characters)
+  * [Mix.Dep] Always specify the `:env` option internally for dependencies to avoid false positives in the dependency resolution
+  * [Mix.Dep] Correctly detect conflict from cousin optional dependencies in the dependency resolution algorithm
 
-### 3. Soft-deprecations (no warnings emitted)
+### 3. Soft deprecations (no warnings emitted)
+
+  * [Float] `Float.to_string/2` and `Float.to_char_list/2` has been soft-deprecated as Elixir will now attempt to print the shortest and most accurate representation by default. Developers can always fallback to `:erlang.float_to_binary/2` and `:erlang.float_to_list/2` if they need the previous functionality
+  * [Kernel] `to_char_list` functions have been soft-deprecated in favor of `to_charlist`. This aligns with the naming conventions in both Erlang and Elixir
+  * [String] The confusing `String.strip/2`, `String.lstrip/2` and `String.rstrip/2` API has been soft deprecated in favor of `String.trim/2`, `String.trim_leading/2` and `String.trim_trailing/2`
+  * [String] The confusing `String.ljust/3` and `String.rjust/3` API has been soft deprecated in favor of `String.pad_leading/3` and `String.pad_trailing/3`
+  * [Typespec] `char_list` is soft-deprecated in favor of `charlist`
+
+### 4. Deprecations
+
+This release deprecates many APIs that have been soft-deprecated in previous Elixir versions.
 
 #### Elixir
 
-  * [Code] Deprecate `Code.load_file/2` in favor of `Code.compile_file/2`
-  * [Code] Deprecate `Code.loaded_files/0` in favor of `Code.required_files/0`
-  * [Code] Deprecate `Code.unload_files/1` in favor of `Code.unrequire_files/1`
-
-#### Logger
-
-  * [Logger] `compile_time_purge_level` is deprecated in favor of `compile_time_purge_matching`
-
-### 4. Hard-deprecations
-
-#### Elixir
-
-  * [Code] `Code.get_docs/2` is deprecated in favor of `Code.fetch_docs/1`
-  * [Enum] `Enum.chunk/2/3/4` is deprecated in favor of `Enum.chunk_every/2/3/4` - notice `chunk_every` does not discard incomplete chunks by default
-  * [GenServer] Warn if `super` is used in any of the GenServer callbacks
-  * [Kernel] `not left in right` is ambiguous and is deprecated in favor of `left not in right`
-  * [Kernel] Warn on confusing operator sequences, such as `1+++1` meaning `1 ++ +1` or `........` meaning `... .. ...`
-  * [OptionParser] Deprecate dynamic option parser mode that depended on atoms to be previously loaded and therefore behaved inconsistently
-  * [Stream] `Stream.chunk/2/3/4` is deprecated in favor of `Stream.chunk_every/2/3/4` - notice `chunk_every` does not discard incomplete chunks by default
-
-## v1.6
-
-The CHANGELOG for v1.6 releases can be found [in the v1.6 branch](https://github.com/elixir-lang/elixir/blob/v1.6/CHANGELOG.md).
+  * [Dict] `Dict` is no longer a behaviour and its functions will be deprecated in upcoming releases
+  * [Enum] Passing a dictionary to `Enum.group_by/3` is deprecated
+  * [Kernel] `\x{H*}` in strings/sigils/charlists is deprecated
+  * [Kernel] Add deprecation for `defdelegate` list arguments and `:append_first` option. The previously undocumented and deprecated support for matching has been removed
+  * [Kernel] Warn if a variable is assigned inside `case`/`if`/etc and used outside the block
+  * [Keyword] `Keyword.size/1` is deprecated in favor of `Kernel.length/1`
+  * [Map] `Map.size/1` is deprecated in favor of `Kernel.map_size/1`
+  * [Regex] The option `/r` (for ungreedy) has been deprecated in favor of `/U`
+  * [Set] `Set` is no longer a behaviour and its functions will be deprecated in upcoming releases
+  * [String] `String.valid_character?/1` is deprecated in favor of `String.valid?/1` with pattern matching
+  * [Task] `Task.find/2` is deprecated in favor of explicit message matching
+  * [URI] Passing a non-map to `URI.decode_query/2` is deprecated

ISSUE_TEMPLATE.md

@@ -1,14 +1,14 @@
 ### Precheck
 
-* Do not use the issues tracker for help or support (try Elixir Forum, Stack Overflow, IRC, etc.)
+* Do not use the issues tracker for help or support (try Stack Overflow, IRC, mailing list, etc)
 * For proposing a new feature, please start a discussion on the Elixir Core mailing list
 * For bugs, do a quick search and make sure the bug has not yet been reported
 * Finally, be nice and have fun!
 
 ### Environment
 
-* Elixir & Erlang/OTP versions (elixir --version): 
-* Operating system: 
+* Elixir version (elixir -v):
+* Operating system:
 
 ### Current behavior
 

LICENSE

@@ -1,201 +1,13 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+Copyright 2012 Plataformatec
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
 
-   1. Definitions.
+      http://www.apache.org/licenses/LICENSE-2.0
 
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2012 Plataformatec
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.

Makefile

@@ -1,14 +1,13 @@
+REBAR ?= "$(CURDIR)/rebar"
 PREFIX ?= /usr/local
-SHARE_PREFIX ?= $(PREFIX)/share
-CANONICAL := v1.7/
+DOCS := v1.3
+CANONICAL := stable
 ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
 ERLC := erlc -I lib/elixir/include
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
-GENERATE_APP := $(CURDIR)/lib/elixir/generate_app.escript
 VERSION := $(strip $(shell cat VERSION))
 Q := @
 LIBDIR := lib
-BINDIR := bin
 INSTALL = install
 INSTALL_DIR = $(INSTALL) -m755 -d
 INSTALL_DATA = $(INSTALL) -m644
@@ -16,17 +15,17 @@ INSTALL_PROGRAM = $(INSTALL) -m755
 GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
 GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | tail -1) )
 
-.PHONY: install compile erlang elixir unicode app build_plt clean_plt dialyze test clean clean_residual_files install_man clean_man docs Docs.zip Precompiled.zip zips
+.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean install_man clean_man docs Docs.zip Precompiled.zip publish_zips publish_docs publish_mix
 .NOTPARALLEL: compile
 
 #==> Functions
 
 define CHECK_ERLANG_RELEASE
-	erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 19)])' -s erlang halt | grep -q '^true'; \
+	$(Q) erl -noshell -eval 'io:fwrite("~s", [erlang:system_info(otp_release) >= "18"])' -s erlang halt | grep -q '^true'; \
 		if [ $$? != 0 ]; then \
-		  echo "At least Erlang/OTP 19.0 is required to build Elixir"; \
-		  exit 1; \
-		fi
+		   echo "At least Erlang 18.0 is required to build Elixir"; \
+		   exit 1; \
+		fi;
 endef
 
 define APP_TEMPLATE
@@ -51,49 +50,45 @@ endef
 
 #==> Compilation tasks
 
-APP := lib/elixir/ebin/elixir.app
-PARSER := lib/elixir/src/elixir_parser.erl
-KERNEL := lib/elixir/ebin/Elixir.Kernel.beam
-UNICODE := lib/elixir/ebin/Elixir.String.Unicode.beam
+KERNEL:=lib/elixir/ebin/Elixir.Kernel.beam
+UNICODE:=lib/elixir/ebin/Elixir.String.Unicode.beam
 
 default: compile
 
-compile: erlang $(APP) elixir
+compile: lib/elixir/src/elixir.app.src erlang elixir
 
-erlang: $(PARSER)
-	$(Q) if [ ! -f $(APP) ]; then $(call CHECK_ERLANG_RELEASE); fi
-	$(Q) cd lib/elixir && mkdir -p ebin && erl -make
+lib/elixir/src/elixir.app.src: src/elixir.app.src
+	$(Q) $(call CHECK_ERLANG_RELEASE)
+	$(Q) rm -rf lib/elixir/src/elixir.app.src
+	$(Q) echo "%% This file is automatically generated from <project_root>/src/elixir.app.src" \
+	                             >lib/elixir/src/elixir.app.src
+	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
 
-$(PARSER): lib/elixir/src/elixir_parser.yrl
-	$(Q) erlc -o $@ +'{verbose,true}' +'{report,true}' $<
+erlang:
+	$(Q) cd lib/elixir && $(REBAR) compile
 
-# Since Mix depends on EEx and EEx depends on Mix,
-# we first compile EEx without the .app file,
-# then Mix and then compile EEx fully
+# Since Mix depends on EEx and EEx depends on
+# Mix, we first compile EEx without the .app
+# file, then mix and then compile EEx fully
 elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
 
 stdlib: $(KERNEL) VERSION
 $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
-	$(Q) if [ ! -f $(KERNEL) ]; then \
-		echo "==> bootstrap (compile)"; \
-		$(ERL) -s elixir_compiler bootstrap -s erlang halt; \
+	$(Q) if [ ! -f $(KERNEL) ]; then                  \
+		echo "==> bootstrap (compile)";                 \
+		$(ERL) -s elixir_compiler core -s erlang halt;  \
 	fi
 	@ echo "==> elixir (compile)";
 	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/kernel.ex" -o ebin;
 	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
 	$(Q) $(MAKE) unicode
-	$(Q) $(MAKE) app
-
-app: $(APP)
-$(APP): lib/elixir/src/elixir.app.src lib/elixir/ebin VERSION $(GENERATE_APP)
-	$(Q) $(GENERATE_APP) $< $@ $(VERSION)
+	$(Q) rm -rf lib/elixir/ebin/elixir.app
+	$(Q) cd lib/elixir && $(REBAR) compile
 
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
-	$(Q) $(ELIXIRC) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/properties.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
 $(eval $(call APP_TEMPLATE,logger,Logger))
@@ -104,51 +99,45 @@ $(eval $(call APP_TEMPLATE,iex,IEx))
 install: compile
 	@ echo "==> elixir (install)"
 	$(Q) for dir in lib/*; do \
-		rm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
+		rm -Rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
 		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
 	done
 	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
 	$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
-	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(BINDIR)"
-	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/*; do \
-		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/"; \
+	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/bin"
+	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/* ; do \
+		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/bin/" ; \
 	done
 	$(MAKE) install_man
 
 clean:
+	cd lib/elixir && $(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -rf $(PARSER)
-	$(Q) $(MAKE) clean_residual_files
+	rm -rf lib/elixir/test/ebin
+	rm -rf lib/*/tmp
+	rm -rf lib/mix/test/fixtures/git_repo
+	rm -rf lib/mix/test/fixtures/deps_on_git_repo
+	rm -rf lib/mix/test/fixtures/git_rebar
+	rm -rf lib/elixir/src/elixir.app.src
+	$(MAKE) clean_man
 
-clean_elixir:
+clean_exbeam:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-clean_residual_files:
-	rm -rf lib/*/_build/
-	rm -rf lib/*/tmp/
-	rm -rf lib/elixir/test/ebin/
-	rm -rf lib/mix/test/fixtures/deps_on_git_repo/
-	rm -rf lib/mix/test/fixtures/git_rebar/
-	rm -rf lib/mix/test/fixtures/git_repo/
-	rm -rf lib/mix/test/fixtures/git_sparse_repo/
-	rm -f erl_crash.dump
-	$(Q) $(MAKE) clean_man
-
-#==> Documentation tasks
+#==> Create Documentation
 
 LOGO_PATH = $(shell test -f ../docs/logo.png && echo "--logo ../docs/logo.png")
 SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}\c")
-DOCS_FORMAT = html
-COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -n https://hexdocs.pm/$(2)/$(CANONICAL) -p http://elixir-lang.org/docs.html -f "$(DOCS_FORMAT)" $(4)
+COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -a http://elixir-lang.org/docs/$(CANONICAL)/$(2)/ -p http://elixir-lang.org/docs.html $(4)
 
 docs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger
 
 docs_elixir: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (elixir)"
 	$(Q) rm -rf doc/elixir
-	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-c lib/elixir/docs.exs)
+	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-e "lib/elixir/pages/Behaviours.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Writing Documentation.md")
 
 docs_eex: compile ../ex_doc/bin/ex_doc
 	@ echo "==> ex_doc (eex)"
@@ -179,45 +168,34 @@ docs_logger: compile ../ex_doc/bin/ex_doc
 	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
 	@ false
 
-#==> Zip tasks
+#==> Zips
 
 Docs.zip: docs
-	rm -f Docs-v$(VERSION).zip
+	rm -rf Docs-v$(VERSION).zip
 	zip -9 -r Docs-v$(VERSION).zip CHANGELOG.md doc NOTICE LICENSE README.md
 	@ echo "Docs file created $(CURDIR)/Docs-v$(VERSION).zip"
 
 Precompiled.zip: build_man compile
-	rm -f Precompiled-v$(VERSION).zip
-	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin lib/*/lib LICENSE man NOTICE README.md VERSION
+	rm -rf Precompiled-v$(VERSION).zip
+	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin LICENSE man NOTICE README.md VERSION
 	@ echo "Precompiled file created $(CURDIR)/Precompiled-v$(VERSION).zip"
 
-zips: Precompiled.zip Docs.zip
-	@ echo ""
-	@ echo "## Checksums"
-	@ echo ""
-	@ shasum -a 1 < Precompiled-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Precompiled.zip SHA1:"
-	@ shasum -a 512 < Precompiled-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Precompiled.zip SHA512:"
-	@ shasum -a 1 < Docs-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Docs.zip SHA1:"
-	@ shasum -a 512 < Docs-v$(VERSION).zip | sed -e "s/-//" | xargs echo "  * Docs.zip SHA512:"
-	@ echo ""
+#==> Publish
 
-#==> Test tasks
+publish_zips: Precompiled.zip Docs.zip
 
-test: test_formatted test_erlang test_elixir
+publish_docs: docs
+	rm -rf ../docs/$(DOCS)/*/
+	cp -R doc/* ../docs/$(DOCS)
 
-test_windows: test test_taskkill
+#==> Tests tasks
 
-test_taskkill:
-	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
-	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
+test: test_erlang test_elixir
 
 TEST_ERL = lib/elixir/test/erlang
 TEST_EBIN = lib/elixir/test/ebin
 TEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))
 
-test_formatted: compile
-	bin/elixir bin/mix format --check-formatted
-
 test_erlang: compile $(TEST_ERLS)
 	@ echo "==> elixir (eunit)"
 	$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;
@@ -262,26 +240,24 @@ build_man: man/iex.1 man/elixir.1
 
 man/iex.1:
 	$(Q) cp man/iex.1.in man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/r man/common" man/iex.1
+	$(Q) sed -i.bak "/{COMMON}/r common" man/iex.1
 	$(Q) sed -i.bak "/{COMMON}/d" man/iex.1
-	$(Q) rm -f man/iex.1.bak
+	$(Q) rm man/iex.1.bak
 
 man/elixir.1:
 	$(Q) cp man/elixir.1.in man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/r man/common" man/elixir.1
+	$(Q) sed -i.bak "/{COMMON}/r common" man/elixir.1
 	$(Q) sed -i.bak "/{COMMON}/d" man/elixir.1
-	$(Q) rm -f man/elixir.1.bak
+	$(Q) rm man/elixir.1.bak
 
 clean_man:
 	rm -f man/elixir.1
-	rm -f man/elixir.1.bak
 	rm -f man/iex.1
-	rm -f man/iex.1.bak
 
 install_man: build_man
-	$(Q) mkdir -p $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
+	$(Q) mkdir -p $(DESTDIR)$(PREFIX)/share/man/man1
+	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(PREFIX)/share/man/man1
+	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(PREFIX)/share/man/man1
+	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(PREFIX)/share/man/man1
+	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(PREFIX)/share/man/man1
 	$(MAKE) clean_man

README.md

@@ -1,14 +1,12 @@
 ![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
 =========
-[![Travis build](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
+[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
 "Build Status")](https://travis-ci.org/elixir-lang/elixir)
 
-Elixir is a dynamic, functional language designed for building scalable and maintainable applications.
-
 For more about Elixir, installation and documentation,
 [check Elixir's website](http://elixir-lang.org/).
 
-## Compiling from source
+## Usage
 
 To run Elixir from source, clone this repository to your machine, compile and test it:
 
@@ -26,48 +24,25 @@ If Elixir fails to build (specifically when pulling in a new version via
 `git`), be sure to remove any previous build artifacts by running
 `make clean`, then `make test`.
 
-If tests pass, you are ready to move on to the [Getting Started guide][1]
-or to try Interactive Elixir by running `bin/iex` in your terminal.
+If tests pass, you are ready to move on to the
+[Getting Started guide][1] or to try Interactive Elixir by running:
+`bin/iex` in your terminal.
 
-However, if tests fail, it is likely you have an outdated Erlang/OTP version
-(Elixir requires Erlang/OTP 19.0 or later). You can check your Erlang/OTP version
+However, if tests fail, it is likely you have an outdated Erlang version
+(Elixir requires Erlang 18.0 or later). You can check your Erlang version
 by calling `erl` in the command line. You will see some information as follows:
 
-    Erlang/OTP 19 [erts-8.0] [smp:2:2] [async-threads:10] [kernel-poll:false]
+    Erlang/OTP 18 [erts-7.0] [source] [smp:2:2] [async-threads:10] [hipe] [kernel-poll:false]
 
-If you have properly set up your dependencies and tests still fail,
-you may want to open up a bug report, as explained next.
-
-## Bug reports
-
-For reporting bugs, [visit our issues tracker][2] and follow the steps
-for reporting a new issue. Please disclose security vulnerabilities
-privately at elixir-security@googlegroups.com.
-
-## Proposing new features
-
-For proposing new features, please start a discussion in the
-[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
-to argue and explain why a feature is useful and how it will impact the
-codebase and the community.
-
-Once a proposal is accepted, it will be added to [the issues tracker][2].
-The issues tracker focuses on *actionable items* and it holds a list of
-upcoming enhancements and pending bugs. All entries in the tracker are
-tagged for clarity and to ease collaboration.
-
-Features and bug fixes that have already been merged and will be included
-in the next release are marked as "closed" in the issues tracker and are
-added to the [CHANGELOG](CHANGELOG.md).
-
-Finally, remember all interactions in our official spaces follow our
-[Code of Conduct][7].
+If you have the correct version and tests still fail, please
+[open an issue][2].
 
 ## Contributing
 
-We welcome everyone to contribute to Elixir. To do so, there are a few
-things you need to know about the code. First, Elixir code is divided
-in applications inside the `lib` folder:
+We welcome everyone to contribute to Elixir and help us tackle
+existing issues! To do so, there are a few things you need to know
+about the code. First, Elixir code is divided in applications inside
+the `lib` folder:
 
 * `elixir` - Contains Elixir's kernel and stdlib
 
@@ -83,10 +58,9 @@ in applications inside the `lib` folder:
 
 You can run all tests in the root directory with `make test` and you can
 also run tests for a specific framework `make test_#{NAME}`, for example,
-`make test_ex_unit`. If you just changed something in the Elixir's standard
-library, you can run only that portion through `make test_stdlib`.
+`make test_ex_unit`.
 
-If you are changing just one file, you can choose to compile and run tests only
+In case you are changing a single file, you can compile and run tests only
 for that particular file for fast development cycles. For example, if you
 are changing the String module, you can compile it and run its tests as:
 
@@ -95,27 +69,12 @@ bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
 bin/elixir lib/elixir/test/elixir/string_test.exs
 ```
 
-To recompile (including Erlang modules):
-
-```sh
-make compile
-```
-
 After your changes are done, please remember to run the full suite with
-`make test` and then `mix format` to guarantee all files are properly
-formatted.
+`make test`.
 
-If your contribution fails during the bootstrapping of the language,
-you can rebuild the language from scratch with:
-
-```sh
-make clean_elixir compile
-```
-
-Similarly, if you can't get Elixir to compile or the tests to pass after
-updating an existing checkout, run `make clean compile`. You can check
-[the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
-More tasks can be found by reading the [Makefile](./Makefile).
+From time to time, your tests may fail in an existing Elixir checkout and
+may require a clean start by running `make clean compile`. You can always
+check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
 
 With tests running and passing, you are ready to contribute to Elixir and
 [send a pull request](https://help.github.com/articles/using-pull-requests/).
@@ -126,28 +85,12 @@ case you are looking for some examples:
 * [Add String.valid? – Pull Request](https://github.com/elixir-lang/elixir/pull/1058)
 * [Implement capture_io for ExUnit – Pull Request](https://github.com/elixir-lang/elixir/pull/1059)
 
-### Reviewing changes
-
-Once a pull request is sent, the Elixir team will review your changes.
-We outline our process below to clarify the roles of everyone involved.
-
-All pull requests must be approved by two committers before being merged into
-the repository. If any changes are necessary, the team will leave appropriate
-comments requesting changes to the code. Unfortunately we cannot guarantee a
-pull request will be merged, even when modifications are requested, as the Elixir
-team will re-evaluate the contribution as it changes.
-
-Committers may also push style changes directly to your branch. If you would
-rather manage all changes yourself, you can disable "Allow edits from maintainers"
-feature when submitting your pull request.
-
-The Elixir team may optionally assign someone to review a pull request.
-If someone is assigned, they must explicitly approve the code before
-another team member can merge it.
-
-When the review finishes, your pull request will be squashed and merged
-into the repository. If you have carefully organized your commits and
-believe they should be merged without squashing, leave a comment.
+We usually keep a list of enhancements and bugs [in the issue tracker][2].
+For proposing a new feature, please start a discussion in the
+[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
+to argue and explain why a feature is useful and how it will impact the
+codebase and the community. Finally, remember all interactions in our official
+spaces follow our [Code of Conduct][7].
 
 ## Building documentation
 
@@ -161,20 +104,20 @@ cd ex_doc && ../elixir/bin/mix do deps.get, compile
 cd ../elixir && make docs
 ```
 
-This will produce documentation sets for `elixir`, `mix`, etc. under
+This will produce documentation sets for `elixir`, `mix`, etc., under
 the `doc` directory. If you are planning to contribute documentation,
-[please check our best practices for writing documentation](https://hexdocs.pm/elixir/writing-documentation.html).
+[please check our best practices for writing documentation](http://elixir-lang.org/docs/stable/elixir/writing-documentation.html).
 
 ## Development links
 
-  * [Elixir Getting Started guide][1]
+  * [Elixir Website][1]
   * [Elixir Documentation][6]
   * [Elixir Core Mailing list (development)][3]
   * [Issues tracker][2]
   * [Code of Conduct][7]
   * **[#elixir-lang][4]** on [Freenode][5] IRC
 
-  [1]: https://elixir-lang.org/getting-started/introduction.html
+  [1]: http://elixir-lang.org
   [2]: https://github.com/elixir-lang/elixir/issues
   [3]: https://groups.google.com/group/elixir-lang-core
   [4]: https://webchat.freenode.net/?channels=#elixir-lang

RELEASE.md

@@ -1,41 +1,49 @@
 # Release process
 
-## Shipping a new version
+## All releases
+
+This document simply outlines the release process:
 
 1. Ensure you are running on the oldest supported Erlang version
 
-2. Update version in /VERSION
+2. Remove all `-dev` extension from versions (see below for all files)
 
-3. Ensure /CHANGELOG.md is updated, versioned and add the current date
+3. Ensure CHANGELOG is updated and add current date
 
-4. Update "Compatibility and Deprecations" if a new OTP version is supported
+4. Commit changes above with title "Release vVERSION" and generate new tag
 
-5. Commit changes above with title "Release vVERSION" and generate a new tag
+5. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-6. Run `make clean test` to ensure all tests pass from scratch and the CI is green
+6. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
 
-7. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
+7. Push branch and the new tag
 
-8. Push branch and the new tag
+8. Publish new docs with `make publish_docs`, copy docs to `docs/stable` if appropriate, and push to GitHub Pages
 
-9. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases, and include SHAs+CHANGELOG
+9. Publish new zips with `make publish_zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
 
-10. Add the release to `elixir.csv` and `_data/elixir-versions.yml` files in `elixir-lang/elixir-lang.github.com`
+10. Add the release to `elixir.csv` file in `elixir-lang/elixir-lang.github.com`
 
-## Creating a new vMAJOR.MINOR branch
+## New vMAJOR.MINOR releases
 
-### In the new branch
+11. Create a new branch "vMAJOR.MINOR"
 
-1. Set `CANONICAL=` in /Makefile
+12. Move docs generation to `docs/vMAJOR.MINOR` in Makefile, set CANONICAL to stable and copy them to `docs/stable` (change index.html accordingly)
 
-2. Update **all** tables in "Compatibility and Deprecations"
+13. In master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vVERSION+1"
 
-3. Commit "Prepare vMAJOR.MINOR for release"
+## Places where version is mentioned
 
-### Back in master
+* VERSION
+* CHANGELOG.md
+* src/elixir.app.src (not lib/elixir/src/elixir.app.src)
 
-1. Bump /VERSION file
+## Deprecation policy
 
-2. Start new /CHANGELOG.md
+Elixir deprecations happens in 3 steps:
 
-3. Commit "Start vMAJOR.MINOR+1"
+  1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.
+
+  2. The feature is effectively deprecated by emitting warnings on usage. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST two versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.3 or later.
+
+  3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.

VERSION

@@ -1 +1 @@
-1.7.4
+1.3.0

bin/elixir

@@ -2,6 +2,7 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
+  -v                          Prints version and exits
   -e COMMAND                  Evaluates the given command (*)
   -r FILE                     Requires the given files/patterns (*)
   -S SCRIPT                   Finds and executes the given script in PATH
@@ -13,14 +14,12 @@ if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   --cookie COOKIE             Sets a cookie for this distributed node
   --detached                  Starts the Erlang VM detached from console
   --erl SWITCHES              Switches to be passed down to Erlang (*)
-  --help, -h                  Prints this message and exits
   --hidden                    Makes a hidden node
   --logger-otp-reports BOOL   Enables or disables OTP reporting
   --logger-sasl-reports BOOL  Enables or disables SASL reporting
   --name NAME                 Makes and assigns a name to the distributed node
   --no-halt                   Does not halt the Erlang VM after execution
   --sname NAME                Makes and assigns a short name to the distributed node
-  --version, -v               Prints Elixir version and exits
   --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
 ** Options marked with (*) can be given more than once
@@ -75,14 +74,14 @@ while [ $I -le $# ]; do
     --logger-otp-reports)
         I=$(expr $I + 1)
         eval "VAL=\${$I}"
-        if [ "$VAL" = 'true' ] || [ "$VAL" = 'false' ]; then
+        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
             ERL="$ERL -logger handle_otp_reports "$VAL""
         fi
         ;;
     --logger-sasl-reports)
         I=$(expr $I + 1)
         eval "VAL=\${$I}"
-        if [ "$VAL" = 'true' ] || [ "$VAL" = 'false' ]; then
+        if [ "$VAL" == 'true' ] || [ "$VAL" == 'false' ]; then
             ERL="$ERL -logger handle_sasl_reports "$VAL""
         fi
         ;;
@@ -117,7 +116,11 @@ if [ "$OS" = "Windows_NT" ] && [ $USE_WERL ]; then
 fi
 
 if [ -z "$ERL_PATH" ]; then
-  ERL_PATH="$ERL_EXEC"
+  if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]; then
+    ERL_PATH="$SCRIPT_PATH"/"$ERL_EXEC"
+  else
+    ERL_PATH="$ERL_EXEC"
+  fi
 fi
 
 exec "$ERL_PATH" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL -extra "$@"

bin/elixir.bat

@@ -1,15 +1,16 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
+@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
 setlocal
-if    ""%1""==""""       goto documentation
-if /I ""%1""==""--help"" goto documentation
-if /I ""%1""==""-h""     goto documentation
-if /I ""%1""==""/h""     goto documentation
-if    ""%1""==""/?""     goto documentation
+if    ""%1""==""""       goto :documentation
+if /I ""%1""==""--help"" goto :documentation
+if /I ""%1""==""-h""     goto :documentation
+if /I ""%1""==""/h""     goto :documentation
+if    ""%1""==""/?""     goto :documentation
 goto parseopts
 
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
+echo   -v                          Prints version and exits
 echo   -e COMMAND                  Evaluates the given command (*)
 echo   -r FILE                     Requires the given files/patterns (*)
 echo   -S SCRIPT                   Finds and executes the given script in PATH
@@ -21,14 +22,12 @@ echo   --app APP                   Starts the given app and its dependencies (*)
 echo   --cookie COOKIE             Sets a cookie for this distributed node
 echo   --detached                  Starts the Erlang VM detached from console
 echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo   --help, -h                  Prints this message and exits
 echo   --hidden                    Makes a hidden node
 echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
 echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
 echo   --name NAME                 Makes and assigns a name to the distributed node
 echo   --no-halt                   Does not halt the Erlang VM after execution
 echo   --sname NAME                Makes and assigns a short name to the distributed node
-echo   --version, -v               Prints Elixir version and exits
 echo   --werl                      Uses Erlang's Windows shell GUI
 echo.
 echo ** Options marked with (*) can be given more than once
@@ -62,52 +61,51 @@ set par="%1"
 shift
 if "%par%"=="" (
   rem if no parameters defined
-  goto expand_erl_libs
+  goto :expand_erl_libs
 )
 if "%par%"=="""" (
   rem if no parameters defined - special case for parameter that is already quoted
-  goto expand_erl_libs
+  goto :expand_erl_libs
 )
 rem ******* EXECUTION OPTIONS **********************
-if "%par%"==""--werl"" (set useWerl=1)
-if "%par%"==""+iex"" (set runMode="iex")
+IF "%par%"==""--werl"" (Set useWerl=1)
+IF "%par%"==""+iex"" (Set runMode="iex")
 rem ******* ELIXIR PARAMETERS **********************
 rem Note: we don't have to do anything with options that don't take an argument
-if """"=="%par:-e=%"      (shift)
-if """"=="%par:-r=%"      (shift)
-if """"=="%par:-pr=%"     (shift)
-if """"=="%par:-pa=%"     (shift)
-if """"=="%par:-pz=%"     (shift)
-if """"=="%par:--app=%"   (shift)
-if """"=="%par:--remsh=%" (shift)
+IF """"=="%par:-e=%"      (shift) 
+IF """"=="%par:-r=%"      (shift) 
+IF """"=="%par:-pr=%"     (shift) 
+IF """"=="%par:-pa=%"     (shift) 
+IF """"=="%par:-pz=%"     (shift) 
+IF """"=="%par:--app=%"   (shift) 
+IF """"=="%par:--remsh=%" (shift) 
 rem ******* ERLANG PARAMETERS **********************
-if """"=="%par:--detached=%"            (set parsErlang=%parsErlang% -detached)
-if """"=="%par:--hidden=%"              (set parsErlang=%parsErlang% -hidden)
-if """"=="%par:--cookie=%"              (set parsErlang=%parsErlang% -setcookie %1 && shift)
-if """"=="%par:--sname=%"               (set parsErlang=%parsErlang% -sname %1 && shift)
-if """"=="%par:--name=%"                (set parsErlang=%parsErlang% -name %1 && shift)
-if """"=="%par:--logger-otp-reports=%"  (set parsErlang=%parsErlang% -logger handle_otp_reports %1 && shift)
-if """"=="%par:--logger-sasl-reports=%" (set parsErlang=%parsErlang% -logger handle_sasl_reports %1 && shift)
-if """"=="%par:--erl=%"                 (set "beforeExtra=%beforeExtra% %~1" && shift)
+IF """"=="%par:--detached=%"            (Set parsErlang=%parsErlang% -detached) 
+IF """"=="%par:--hidden=%"              (Set parsErlang=%parsErlang% -hidden)
+IF """"=="%par:--cookie=%"              (Set parsErlang=%parsErlang% -setcookie %1 && shift)
+IF """"=="%par:--sname=%"               (Set parsErlang=%parsErlang% -sname %1 && shift) 
+IF """"=="%par:--name=%"                (Set parsErlang=%parsErlang% -name %1 && shift) 
+IF """"=="%par:--logger-otp-reports=%"  (Set parsErlang=%parsErlang% -logger handle_otp_reports %1 && shift) 
+IF """"=="%par:--logger-sasl-reports=%" (Set parsErlang=%parsErlang% -logger handle_sasl_reports %1 && shift) 
+IF """"=="%par:--erl=%"                 (Set beforeExtra=%beforeExtra% %~1 && shift) 
 goto:startloop
 
 rem ******* assume all pre-params are parsed ********************
 :expand_erl_libs
 rem ******* expand all ebin paths as Windows does not support the ..\*\ebin wildcard ********************
-setlocal enabledelayedexpansion
+SETLOCAL enabledelayedexpansion
 set ext_libs=
 for  /d %%d in ("%originPath%..\lib\*.") do (
   set ext_libs=!ext_libs! -pa "%%~fd\ebin"
 )
-setlocal disabledelayedexpansion
-
+SETLOCAL disabledelayedexpansion
 :run
-if not %runMode% == "iex" (
+IF NOT %runMode% == "iex" (
   set beforeExtra=-noshell -s elixir start_cli %beforeExtra%
 )
-if %useWerl% equ 1 (
+IF %useWerl% EQU 1 (
   start werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
-) else (
+) ELSE (
   erl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
 )
 :end

bin/elixirc

@@ -2,15 +2,12 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
 
-  -o                        The directory to output compiled files
-
-  --help, -h                Prints this message and exits
-  --ignore-module-conflict  Does not emit warnings if a module was previously defined
-  --no-debug-info           Does not attach debug info to compiled modules
-  --no-docs                 Does not attach documentation to compiled modules
-  --verbose                 Prints compilation status
-  --version, -v             Prints Elixir version and exits
-  --warnings-as-errors      Treats warnings as errors and return non-zero exit code
+  -o                   The directory to output compiled files
+  --no-docs            Do not attach documentation to compiled modules
+  --no-debug-info      Do not attach debug info to compiled modules
+  --verbose            Print compilation status
+  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  --ignore-module-conflict
 
 ** Options given after -- are passed down to the executed code
 ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS

bin/elixirc.bat

@@ -1,12 +1,12 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
+@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
 setlocal
 set argc=0
 for %%A in (%*) do (
-  if /I "%%A"=="--help" goto documentation
-  if /I "%%A"=="-h"     goto documentation
-  if /I "%%A"=="/h"     goto documentation
-  if    "%%A"=="/?"     goto documentation
-  set /A argc+=1
+    if /I "%%A"=="--help" goto documentation
+    if /I "%%A"=="-h"     goto documentation
+    if /I "%%A"=="/h"     goto documentation
+    if    "%%A"=="/?"     goto documentation
+    set /A argc+=1
 )
 if %argc%==0 goto documentation
 goto run
@@ -14,15 +14,12 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo   -o                        The directory to output compiled files
-echo.
-echo   --help, -h                Prints this message and exits
-echo   --ignore-module-conflict  Does not emit warnings if a module was previously defined
-echo   --no-debug-info           Does not attach debug info to compiled modules
-echo   --no-docs                 Does not attach documentation to compiled modules
-echo   --verbose                 Prints compilation status
-echo   --version, -v             Prints Elixir version and exits
-echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit code
+echo  -o                   The directory to output compiled files
+echo  --no-docs            Do not attach documentation to compiled modules
+echo  --no-debug-info      Do not attach debug info to compiled modules
+echo  --verbose            Print compilation status
+echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  --ignore-module-conflict
 echo.
 echo ** Options given after -- are passed down to the executed code
 echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS

bin/iex

@@ -2,6 +2,7 @@
 if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
+  -v                          Prints version and exits
   -e COMMAND                  Evaluates the given command (*)
   -r FILE                     Requires the given files/patterns (*)
   -S SCRIPT                   Finds and executes the given script in PATH
@@ -13,14 +14,12 @@ if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
   --cookie COOKIE             Sets a cookie for this distributed node
   --detached                  Starts the Erlang VM detached from console
   --erl SWITCHES              Switches to be passed down to Erlang (*)
-  --help, -h                  Prints this message and exits
   --hidden                    Makes a hidden node
   --logger-otp-reports BOOL   Enables or disables OTP reporting
   --logger-sasl-reports BOOL  Enables or disables SASL reporting
   --name NAME                 Makes and assigns a name to the distributed node
   --no-halt                   Does not halt the Erlang VM after execution
   --sname NAME                Makes and assigns a short name to the distributed node
-  --version, -v               Prints IEx version and exits
   --werl                      Uses Erlang's Windows shell GUI (Windows only)
 
   --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
@@ -45,4 +44,4 @@ readlink_f () {
 
 SELF=$(readlink_f "$0")
 SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir --no-halt --erl "-noshell -user Elixir.IEx.CLI" +iex "$@"
+exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user Elixir.IEx.CLI" +iex "$@"

bin/iex.bat

@@ -1,5 +1,5 @@
 @if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
-setlocal
+SETLOCAL
 if /I ""%1""==""--help"" goto documentation
 if /I ""%1""==""-h""     goto documentation
 if /I ""%1""==""/h""     goto documentation
@@ -9,30 +9,29 @@ goto run
 :documentation
 echo Usage: %~nx0 [options] [.exs file] [data]
 echo.
-echo   -e COMMAND                  Evaluates the given command (*)
-echo   -r FILE                     Requires the given files/patterns (*)
-echo   -S SCRIPT                   Finds and executes the given script in PATH
-echo   -pr FILE                    Requires the given files/patterns in parallel (*)
-echo   -pa PATH                    Prepends the given path to Erlang code path (*)
-echo   -pz PATH                    Appends the given path to Erlang code path (*)
+echo  -v                          Prints version and exits
+echo  -e COMMAND                  Evaluates the given command (*)
+echo  -r FILE                     Requires the given files/patterns (*)
+echo  -S SCRIPT                   Finds and executes the given script in PATH
+echo  -pr FILE                    Requires the given files/patterns in parallel (*)
+echo  -pa PATH                    Prepends the given path to Erlang code path (*)
+echo  -pz PATH                    Appends the given path to Erlang code path (*)
 echo.
-echo   --app APP                   Starts the given app and its dependencies (*)
-echo   --cookie COOKIE             Sets a cookie for this distributed node
-echo   --detached                  Starts the Erlang VM detached from console
-echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo   --help, -h                  Prints this message and exits
-echo   --hidden                    Makes a hidden node
-echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
-echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
-echo   --name NAME                 Makes and assigns a name to the distributed node
-echo   --no-halt                   Does not halt the Erlang VM after execution
-echo   --sname NAME                Makes and assigns a short name to the distributed node
-echo   --version, -v               Prints IEx version and exits
-echo   --werl                      Uses Erlang's Windows shell GUI (Windows only)
+echo  --app APP                   Starts the given app and its dependencies (*)
+echo  --cookie COOKIE             Sets a cookie for this distributed node
+echo  --detached                  Starts the Erlang VM detached from console
+echo  --erl SWITCHES              Switches to be passed down to Erlang (*)
+echo  --hidden                    Makes a hidden node
+echo  --logger-otp-reports BOOL   Enables or disables OTP reporting
+echo  --logger-sasl-reports BOOL  Enables or disables SASL reporting
+echo  --name NAME                 Makes and assigns a name to the distributed node
+echo  --no-halt                   Does not halt the Erlang VM after execution
+echo  --sname NAME                Makes and assigns a short name to the distributed node
+echo  --werl                      Uses Erlang's Windows shell GUI (Windows only)
 echo.
-echo   --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
-echo                               path can be empty, then no file will be loaded
-echo   --remsh NAME                Connects to a node using a remote shell
+echo  --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
+echo                              path can be empty, then no file will be loaded
+echo  --remsh NAME                Connects to a node using a remote shell
 echo.
 echo ** Options marked with (*) can be given more than once
 echo ** Options given after the .exs file or -- are passed down to the executed code
@@ -41,6 +40,6 @@ goto end
 
 :run
 @if defined IEX_WITH_WERL (@set __ELIXIR_IEX_FLAGS=--werl) else (set __ELIXIR_IEX_FLAGS=)
-call "%~dp0\elixir.bat" --no-halt --erl "-noshell -user Elixir.IEx.CLI" +iex %__ELIXIR_IEX_FLAGS% %*
+call "%~dp0\elixir.bat" +iex --erl "-user Elixir.IEx.CLI" --no-halt %__ELIXIR_IEX_FLAGS% %*
 :end
-endlocal
+ENDLOCAL

bin/mix.bat

@@ -1,2 +1,2 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
-call "%~dp0\elixir.bat" "%~dp0\mix" %*
+@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
+call "%~dp0\elixir.bat" "%~dp0\mix" %*

lib/eex/lib/eex.ex

@@ -1,7 +1,6 @@
 defmodule EEx.SyntaxError do
   defexception [:message, :file, :line]
 
-  @impl true
   def message(exception) do
     "#{exception.file}:#{exception.line}: #{exception.message}"
   end
@@ -12,7 +11,7 @@ defmodule EEx do
   EEx stands for Embedded Elixir. It allows you to embed
   Elixir code inside a string in a robust way.
 
-      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
 
   ## API
@@ -84,7 +83,7 @@ defmodule EEx do
   An example is the `@` macro which allows easy data access
   in a template:
 
-      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
+      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
       "1"
 
   In other words, `<%= @foo %>` translates to:
@@ -112,14 +111,14 @@ defmodule EEx do
 
   """
   defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
-    quote bind_quoted: binding() do
-      info = Keyword.merge([file: __ENV__.file, line: __ENV__.line], options)
-      args = Enum.map(args, fn arg -> {arg, [line: info[:line]], nil} end)
+    quote bind_quoted: binding do
+      info = Keyword.merge [file: __ENV__.file, line: __ENV__.line], options
+      args = Enum.map args, fn arg -> {arg, [line: info[:line]], nil} end
       compiled = EEx.compile_string(source, info)
 
       case kind do
-        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
-        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
       end
     end
   end
@@ -149,16 +148,16 @@ defmodule EEx do
 
   """
   defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
-    quote bind_quoted: binding() do
-      info = Keyword.merge(options, file: file, line: 1)
-      args = Enum.map(args, fn arg -> {arg, [line: 1], nil} end)
+    quote bind_quoted: binding do
+      info = Keyword.merge options, [file: file, line: 1]
+      args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
       compiled = EEx.compile_file(file, info)
 
       @external_resource file
       @file file
       case kind do
-        :def -> def unquote(name)(unquote_splicing(args)), do: unquote(compiled)
-        :defp -> defp unquote(name)(unquote_splicing(args)), do: unquote(compiled)
+        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
+        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
       end
     end
   end
@@ -167,8 +166,7 @@ defmodule EEx do
   Gets a string `source` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
   """
-  @spec compile_string(String.t(), keyword) :: Macro.t() | no_return
-  def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
+  def compile_string(source, options \\ []) do
     EEx.Compiler.compile(source, options)
   end
 
@@ -176,9 +174,8 @@ defmodule EEx do
   Gets a `filename` and generate a quoted expression
   that can be evaluated by Elixir or compiled to a function.
   """
-  @spec compile_file(String.t(), keyword) :: Macro.t() | no_return
-  def compile_file(filename, options \\ []) when is_binary(filename) and is_list(options) do
-    options = Keyword.merge(options, file: filename, line: 1)
+  def compile_file(filename, options \\ []) do
+    options = Keyword.merge options, [file: filename, line: 1]
     compile_string(File.read!(filename), options)
   end
 
@@ -187,13 +184,11 @@ defmodule EEx do
 
   ## Examples
 
-      iex> EEx.eval_string("foo <%= bar %>", bar: "baz")
+      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
       "foo baz"
 
   """
-  @spec eval_string(String.t(), keyword, keyword) :: any
-  def eval_string(source, bindings \\ [], options \\ [])
-      when is_binary(source) and is_list(bindings) and is_list(options) do
+  def eval_string(source, bindings \\ [], options \\ []) do
     compiled = compile_string(source, options)
     do_eval(compiled, bindings, options)
   end
@@ -210,10 +205,8 @@ defmodule EEx do
       EEx.eval_file "sample.eex", [bar: "baz"] #=> "foo baz"
 
   """
-  @spec eval_file(String.t(), keyword, keyword) :: any
-  def eval_file(filename, bindings \\ [], options \\ [])
-      when is_binary(filename) and is_list(bindings) and is_list(options) do
-    options = Keyword.put(options, :file, filename)
+  def eval_file(filename, bindings \\ [], options \\ []) do
+    options  = Keyword.put options, :file, filename
     compiled = compile_file(filename, options)
     do_eval(compiled, bindings, options)
   end

lib/eex/lib/eex/compiler.ex

@@ -9,111 +9,55 @@ defmodule EEx.Compiler do
   and the engine together by handling the tokens and invoking
   the engine every time a full expression or text is received.
   """
-  @spec compile(String.t(), keyword) :: Macro.t() | no_return
-  def compile(source, opts) when is_binary(source) and is_list(opts) do
-    file = opts[:file] || "nofile"
-    line = opts[:line] || 1
-    trim = opts[:trim] || false
-
+  def compile(source, opts) do
+    file   = opts[:file] || "nofile"
+    line   = opts[:line] || 1
+    trim   = opts[:trim] || false
     case EEx.Tokenizer.tokenize(source, line, trim: trim) do
       {:ok, tokens} ->
-        state = %{
-          engine: opts[:engine] || @default_engine,
-          file: file,
-          line: line,
-          quoted: [],
-          start_line: nil
-        }
-
-        init = state.engine.init(opts)
-        generate_buffer(tokens, init, [], state)
-
+        state = %{engine: opts[:engine] || @default_engine,
+                  file: file, line: line, quoted: [], start_line: nil}
+        generate_buffer(tokens, state.engine.init(opts), [], state)
       {:error, line, message} ->
         raise EEx.SyntaxError, line: line, file: file, message: message
     end
   end
 
-  # Generates the buffers by handling each expression from the tokenizer.
-  # It returns Macro.t/0 or it raises.
+  # Generates the buffers by handling each expression from the tokenizer
 
-  defp generate_buffer([{:text, chars} | rest], buffer, scope, state) do
+  defp generate_buffer([{:text, chars} | t], buffer, scope, state) do
     buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, line, mark, chars} | rest], buffer, scope, state) do
-    expr = Code.string_to_quoted!(chars, line: line, file: state.file)
+  defp generate_buffer([{:expr, line, mark, chars} | t], buffer, scope, state) do
+    expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
     buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:start_expr, start_line, mark, chars} | rest], buffer, scope, state) do
-    {contents, line, rest} = look_ahead_text(rest, start_line, chars)
-
-    {contents, rest} =
-      generate_buffer(rest, state.engine.handle_begin(buffer), [contents | scope], %{
-        state
-        | quoted: [],
-          line: line,
-          start_line: start_line
-      })
-
+  defp generate_buffer([{:start_expr, start_line, mark, chars} | t], buffer, scope, state) do
+    {contents, line, t} = look_ahead_text(t, start_line, chars)
+    {contents, t} = generate_buffer(t, "", [contents | scope],
+                                    %{state | quoted: [], line: line, start_line: start_line})
     buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)
-    generate_buffer(rest, buffer, scope, state)
+    generate_buffer(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:middle_expr, line, '', chars} | rest], buffer, [current | scope], state) do
+  defp generate_buffer([{:middle_expr, line, _, chars} | t], buffer, [current | scope], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    state = %{state | line: line}
-    generate_buffer(rest, state.engine.handle_begin(buffer), [wrapped | scope], state)
+    generate_buffer(t, "", [wrapped | scope], %{state | line: line})
   end
 
-  defp generate_buffer(
-         [{:middle_expr, line, modifier, chars} | t],
-         buffer,
-         [_ | _] = scope,
-         state
-       ) do
-    message =
-      "unexpected beginning of EEx tag \"<%#{modifier}\" on \"<%#{modifier}#{chars}%>\", " <>
-        "please remove \"#{modifier}\" accordingly"
-
-    :elixir_errors.warn(line, state.file, message)
-    generate_buffer([{:middle_expr, line, '', chars} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
-  end
-
-  defp generate_buffer([{:middle_expr, line, _, chars} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected middle of expression <%#{chars}%>",
-      file: state.file,
-      line: line
-  end
-
-  defp generate_buffer([{:end_expr, line, '', chars} | rest], buffer, [current | _], state) do
+  defp generate_buffer([{:end_expr, line, _, chars} | t], buffer, [current | _], state) do
     {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    tuples = Code.string_to_quoted!(wrapped, line: state.start_line, file: state.file)
+    tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
     buffer = insert_quoted(tuples, state.quoted)
-    {buffer, rest}
-  end
-
-  defp generate_buffer([{:end_expr, line, modifier, chars} | t], buffer, [_ | _] = scope, state) do
-    message =
-      "unexpected beginning of EEx tag \"<%#{modifier}\" on end of " <>
-        "expression \"<%#{modifier}#{chars}%>\", please remove \"#{modifier}\" accordingly"
-
-    :elixir_errors.warn(line, state.file, message)
-    generate_buffer([{:end_expr, line, '', chars} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
+    {buffer, t}
   end
 
   defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of expression <%#{chars}%>",
-      file: state.file,
-      line: line
+    raise EEx.SyntaxError, message: "unexpected token #{inspect chars}", file: state.file, line: line
   end
 
   defp generate_buffer([], buffer, [], state) do
@@ -121,10 +65,8 @@ defmodule EEx.Compiler do
   end
 
   defp generate_buffer([], _buffer, _scope, state) do
-    raise EEx.SyntaxError,
-      message: "unexpected end of string, expected a closing '<% end %>'",
-      file: state.file,
-      line: state.line
+    raise EEx.SyntaxError, message: "unexpected end of string, expected a closing '<% end %>'",
+                           file: state.file, line: state.line
   end
 
   # Creates a placeholder and wrap it inside the expression block
@@ -133,32 +75,22 @@ defmodule EEx.Compiler do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.quoted)
     placeholder = '__EEX__(' ++ Integer.to_charlist(key) ++ ');'
-    count = current ++ placeholder ++ new_lines ++ chars
-    new_state = %{state | quoted: [{key, state.engine.handle_end(buffer)} | state.quoted]}
-
-    {count, new_state}
+    {current ++ placeholder ++ new_lines ++ chars,
+     %{state | quoted: [{key, buffer} | state.quoted]}}
   end
 
   # Look text ahead on expressions
 
-  defp look_ahead_text(
-         [{:text, text}, {:middle_expr, line, _, chars} | rest] = tokens,
-         start,
-         contents
-       ) do
+  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars} | t]=list, start, contents) do
     if only_spaces?(text) do
-      {contents ++ text ++ chars, line, rest}
+      {contents ++ text ++ chars, line, t}
     else
-      {contents, start, tokens}
+      {contents, start, list}
     end
   end
 
-  defp look_ahead_text([{:middle_expr, line, _, chars} | rest], _start, contents) do
-    {contents ++ chars, line, rest}
-  end
-
-  defp look_ahead_text(tokens, start, contents) do
-    {contents, start, tokens}
+  defp look_ahead_text(t, start, contents) do
+    {contents, start, t}
   end
 
   defp only_spaces?(chars) do
@@ -168,7 +100,7 @@ defmodule EEx.Compiler do
   # Changes placeholder to real expression
 
   defp insert_quoted({:__EEX__, _, [key]}, quoted) do
-    {^key, value} = List.keyfind(quoted, key, 0)
+    {^key, value} = List.keyfind quoted, key, 0
     value
   end
 
@@ -181,7 +113,7 @@ defmodule EEx.Compiler do
   end
 
   defp insert_quoted(list, quoted) when is_list(list) do
-    Enum.map(list, &insert_quoted(&1, quoted))
+    Enum.map list, &insert_quoted(&1, quoted)
   end
 
   defp insert_quoted(other, _quoted) do

lib/eex/lib/eex/engine.ex

@@ -2,43 +2,23 @@ defmodule EEx.Engine do
   @moduledoc ~S"""
   Basic EEx engine that ships with Elixir.
 
-  An engine needs to implement six functions:
+  An engine needs to implement three functions:
 
-    * `init(opts)` - called at the beginning of every text
-      and it must return the initial state.
+    * `init(opts)` - returns the initial buffer
 
-    * `handle_body(state)` - receives the state of the document
-      and it must return a quoted expression.
+    * `handle_body(quoted)` - receives the final built quoted
+      expression, should do final post-processing and return a
+      quoted expression.
 
-    * `handle_text(state, text)` - it receives the state,
+    * `handle_text(buffer, text)` - it receives the buffer,
       the text and must return a new quoted expression.
 
-    * `handle_expr(state, marker, expr)` - it receives the state,
-      the marker, the expr and must return a new state.
-
-    * `handle_begin(state)` - called every time there a new state
-      is needed with an empty buffer. Typically called for do/end
-      blocks, case expressions, anonymous functions, etc
-
-    * `handle_end(state)` - opposite of `handle_begin(state)` and
-      it must return quoted expression
+    * `handle_expr(buffer, marker, expr)` - it receives the buffer,
+      the marker, the expr and must return a new quoted expression.
 
       The marker is what follows exactly after `<%`. For example,
       `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
-      as marker. The allowed markers so far are: 
-
-        * `""`
-        * `"="`
-        * `"/"`
-        * `"|"`
-
-      Markers `"/"` and `"|"` are only for use in custom EEx engines
-      and are not implemented by default. Using them without the
-      implementation raises `EEx.SyntaxError`.
-
-      If your engine does not implement all markers, please ensure that
-      `handle_expr/3` falls back to `EEx.Engine.handle_expr/3` 
-      to raise the proper error message.
+      as marker. The allowed markers so far are: `""` and `"="`.
 
       Read `handle_expr/3` below for more information about the markers
       implemented by default by this engine.
@@ -47,14 +27,10 @@ defmodule EEx.Engine do
   default implementations for the functions above.
   """
 
-  @type state :: term
-
-  @callback init(opts :: keyword) :: state
-  @callback handle_body(state) :: Macro.t()
-  @callback handle_text(state, text :: String.t()) :: state
-  @callback handle_expr(state, marker :: String.t(), expr :: Macro.t()) :: state
-  @callback handle_begin(state) :: state
-  @callback handle_end(state) :: Macro.t()
+  @callback init(Keyword.t) :: Macro.t
+  @callback handle_body(Macro.t) :: Macro.t
+  @callback handle_text(Macro.t, String.t) :: Macro.t
+  @callback handle_expr(Macro.t, String.t, Macro.t) :: Macro.t
 
   @doc false
   defmacro __using__(_) do
@@ -65,16 +41,8 @@ defmodule EEx.Engine do
         EEx.Engine.init(opts)
       end
 
-      def handle_body(quoted) do
-        EEx.Engine.handle_body(quoted)
-      end
-
-      def handle_begin(quoted) do
-        EEx.Engine.handle_begin(quoted)
-      end
-
-      def handle_end(quoted) do
-        EEx.Engine.handle_end(quoted)
+      def handle_body(body) do
+        EEx.Engine.handle_body(body)
       end
 
       def handle_text(buffer, text) do
@@ -85,7 +53,7 @@ defmodule EEx.Engine do
         EEx.Engine.handle_expr(buffer, marker, expr)
       end
 
-      defoverridable EEx.Engine
+      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2, init: 1]
     end
   end
 
@@ -104,33 +72,25 @@ defmodule EEx.Engine do
       end
 
   """
-  @spec handle_assign(Macro.t()) :: Macro.t()
   def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
     line = meta[:line] || 0
-    quote(line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name)))
+    quote line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name))
   end
-
   def handle_assign(arg) do
     arg
   end
 
   @doc false
   # TODO: Raise on 2.0
-  @spec fetch_assign!(Access.t(), Access.key()) :: term | nil
   def fetch_assign!(assigns, key) do
     case Access.fetch(assigns, key) do
       {:ok, val} ->
         val
-
       :error ->
         keys = Enum.map(assigns, &elem(&1, 0))
-
-        IO.warn(
-          "assign @#{key} not available in EEx template. " <>
-            "Please ensure all assigns are given as options. " <>
-            "Available assigns: #{inspect(keys)}"
-        )
-
+        IO.warn "assign @#{key} not available in EEx template. " <>
+                "Please ensure all assigns are given as options. " <>
+                "Available assigns: #{inspect keys}"
         nil
     end
   end
@@ -142,20 +102,6 @@ defmodule EEx.Engine do
     ""
   end
 
-  @doc """
-  Returns an empty string as the new buffer.
-  """
-  def handle_begin(_previous) do
-    ""
-  end
-
-  @doc """
-  End of the new buffer.
-  """
-  def handle_end(quoted) do
-    quoted
-  end
-
   @doc """
   The default implementation simply returns the given expression.
   """
@@ -167,7 +113,7 @@ defmodule EEx.Engine do
   The default implementation simply concatenates text to the buffer.
   """
   def handle_text(buffer, text) do
-    quote(do: unquote(buffer) <> unquote(text))
+    quote do: unquote(buffer) <> unquote(text)
   end
 
   @doc """
@@ -175,11 +121,10 @@ defmodule EEx.Engine do
 
       <% Elixir expression - inline with output %>
       <%= Elixir expression - replace with result %>
-      <%/ Elixir expression - raise EEx.SyntaxError, to be implemented by custom engines %>
-      <%| Elixir expression - raise EEx.SyntaxError, to be implemented by custom engines %>
 
   All other markers are not implemented by this engine.
   """
+  @spec handle_expr(Macro.t, String.t, Macro.t) :: Macro.t
   def handle_expr(buffer, "=", expr) do
     quote do
       tmp1 = unquote(buffer)
@@ -194,9 +139,4 @@ defmodule EEx.Engine do
       tmp2
     end
   end
-
-  def handle_expr(_buffer, marker, _expr) when marker in ["/", "|"] do
-    raise EEx.SyntaxError,
-          "unsupported EEx syntax <%#{marker} %> (the syntax is valid but not supported by the current EEx engine)"
-  end
 end

lib/eex/lib/eex/tokenizer.ex

@@ -1,51 +1,39 @@
 defmodule EEx.Tokenizer do
   @moduledoc false
 
-  @type content :: IO.chardata()
-  @type line :: non_neg_integer
-  @type marker :: '=' | '/' | '|' | ''
-  @type token ::
-          {:text, content}
-          | {:expr | :start_expr | :middle_expr | :end_expr, line, marker, content}
-
   @doc """
   Tokenizes the given charlist or binary.
 
   It returns {:ok, list} with the following tokens:
 
-    * `{:text, content}`
-    * `{:expr, line, marker, content}`
-    * `{:start_expr, line, marker, content}`
-    * `{:middle_expr, line, marker, content}`
-    * `{:end_expr, line, marker, content}`
+    * `{:text, contents}`
+    * `{:expr, line, marker, contents}`
+    * `{:start_expr, line, marker, contents}`
+    * `{:middle_expr, line, marker, contents}`
+    * `{:end_expr, line, marker, contents}`
 
   Or `{:error, line, error}` in case of errors.
   """
-  @spec tokenize(binary | charlist, line, keyword) :: {:ok, [token]} | {:error, line, String.t()}
   def tokenize(bin, line, opts \\ [])
 
-  def tokenize(bin, line, opts)
-      when is_binary(bin) and is_integer(line) and line >= 0 and is_list(opts) do
+  def tokenize(bin, line, opts) when is_binary(bin) do
     tokenize(String.to_charlist(bin), line, opts)
   end
 
-  def tokenize(list, line, opts)
-      when is_list(list) and is_integer(line) and line >= 0 and is_list(opts) do
+  def tokenize(list, line, opts) do
     tokenize(list, line, opts, [], [])
   end
 
   defp tokenize('<%%' ++ t, line, opts, buffer, acc) do
-    tokenize(t, line, opts, [?%, ?< | buffer], acc)
+   tokenize t, line, opts, [?%, ?< | buffer], acc
   end
 
   defp tokenize('<%#' ++ t, line, opts, buffer, acc) do
     case expr(t, line, []) do
-      {:error, _, _} = error ->
-        error
-
+      {:error, _, _} = error -> error
       {:ok, _, new_line, rest} ->
         {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        tokenize(rest, new_line, opts, buffer, acc)
+        tokenize rest, new_line, opts, buffer, acc
     end
   end
 
@@ -53,24 +41,22 @@ defmodule EEx.Tokenizer do
     {marker, t} = retrieve_marker(t)
 
     case expr(t, line, []) do
-      {:error, _, _} = error ->
-        error
-
+      {:error, _, _} = error -> error
       {:ok, expr, new_line, rest} ->
         token = token_name(expr)
         {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        acc = tokenize_text(buffer, acc)
+        acc   = tokenize_text(buffer, acc)
         final = {token, line, marker, Enum.reverse(expr)}
-        tokenize(rest, new_line, opts, [], [final | acc])
+        tokenize rest, new_line, opts, [], [final | acc]
     end
   end
 
   defp tokenize('\n' ++ t, line, opts, buffer, acc) do
-    tokenize(t, line + 1, opts, [?\n | buffer], acc)
+    tokenize t, line + 1, opts, [?\n | buffer], acc
   end
 
   defp tokenize([h | t], line, opts, buffer, acc) do
-    tokenize(t, line, opts, [h | buffer], acc)
+    tokenize t, line, opts, [h | buffer], acc
   end
 
   defp tokenize([], _line, _opts, buffer, acc) do
@@ -79,8 +65,8 @@ defmodule EEx.Tokenizer do
 
   # Retrieve marker for <%
 
-  defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
-    {[marker], t}
+  defp retrieve_marker('=' ++ t) do
+    {'=', t}
   end
 
   defp retrieve_marker(t) do
@@ -94,11 +80,11 @@ defmodule EEx.Tokenizer do
   end
 
   defp expr('\n' ++ t, line, buffer) do
-    expr(t, line + 1, [?\n | buffer])
+    expr t, line + 1, [?\n | buffer]
   end
 
   defp expr([h | t], line, buffer) do
-    expr(t, line, [h | buffer])
+    expr t, line, [h | buffer]
   end
 
   defp expr([], line, _buffer) do
@@ -129,8 +115,8 @@ defmodule EEx.Tokenizer do
     # token and, if so, it is not followed by an "end"
     # token. If this is the case, we are on a start expr.
     case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
-      {:ok, tokens} ->
-        tokens = Enum.reverse(tokens)
+      {:ok, _line, _column, tokens} ->
+        tokens   = Enum.reverse(tokens)
         fn_index = fn_index(tokens)
 
         if fn_index && end_index(tokens) > fn_index do
@@ -138,28 +124,27 @@ defmodule EEx.Tokenizer do
         else
           :middle_expr
         end
-
       _error ->
         :middle_expr
     end
   end
 
-  defp token_name('esle' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('retfa' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('hctac' ++ t), do: check_spaces(t, :middle_expr)
+  defp token_name('esle' ++ t),   do: check_spaces(t, :middle_expr)
+  defp token_name('retfa' ++ t),  do: check_spaces(t, :middle_expr)
+  defp token_name('hctac' ++ t),  do: check_spaces(t, :middle_expr)
   defp token_name('eucser' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('dne' ++ t), do: check_spaces(t, :end_expr)
+  defp token_name('dne' ++ t),    do: check_spaces(t, :end_expr)
 
   defp token_name(_) do
     :expr
   end
 
   defp fn_index(tokens) do
-    Enum.find_index(tokens, fn
+    Enum.find_index tokens, fn
       {:fn_paren, _} -> true
-      {:fn, _} -> true
-      _ -> false
-    end)
+      {:fn, _}       -> true
+      _              -> false
+    end
   end
 
   defp end_index(tokens) do
@@ -188,14 +173,13 @@ defmodule EEx.Tokenizer do
   # If trim mode is enabled and the token is on a line with
   # only itself and whitespace, trim the whitespace around it,
   # including the line break following it if there is one.
+
   defp trim_if_needed(rest, line, opts, buffer, acc) do
     original = {rest, line, buffer}
-
     if opts[:trim] do
       case {trim_left(buffer, acc), trim_right(rest, line)} do
         {{true, new_buffer}, {true, new_rest, new_line}} ->
           {new_rest, new_line, new_buffer}
-
         _ ->
           original
       end

lib/eex/mix.exs

@@ -1,11 +1,9 @@
-defmodule EEx.MixProject do
+defmodule EEx.Mixfile do
   use Mix.Project
 
   def project do
-    [
-      app: :eex,
-      version: System.version(),
-      build_per_environment: false
-    ]
+    [app: :eex,
+     version: System.version,
+     build_per_environment: false]
   end
 end

lib/eex/test/eex/smart_engine_test.exs

@@ -1,48 +1,45 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.SmartEngineTest do
-  # TODO: Make this async: true once capture_io is removed
-  use ExUnit.Case
+  use ExUnit.Case, async: true
+
+  import ExUnit.CaptureIO
 
   test "evaluates simple string" do
-    assert_eval("foo bar", "foo bar")
+    assert_eval "foo bar", "foo bar"
   end
 
   test "evaluates with assigns as keywords" do
-    assert_eval("1", "<%= @foo %>", assigns: [foo: 1])
+    assert_eval "1", "<%= @foo %>", assigns: [foo: 1]
   end
 
   test "evaluates with assigns as a map" do
-    assert_eval("1", "<%= @foo %>", assigns: %{foo: 1})
+    assert_eval "1", "<%= @foo %>", assigns: %{foo: 1}
   end
 
   test "error with missing assigns" do
-    stderr =
-      ExUnit.CaptureIO.capture_io(:stderr, fn ->
-        assert_eval("", "<%= @foo %>", assigns: %{})
-      end)
-
+    stderr = capture_io(:stderr, fn ->
+      assert_eval "", "<%= @foo %>", assigns: %{}
+    end)
     assert stderr =~ "assign @foo not available in EEx template"
   end
 
   test "evaluates with loops" do
-    assert_eval("1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>")
+    assert_eval "1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>"
   end
 
-  test "preserves line numbers" do
+  test "compiled preserved line numbers" do
     result = EEx.compile_string("<%= @hello %>", engine: EEx.SmartEngine)
-
     Macro.prewalk(result, fn
       {_left, meta, _right} ->
         assert Keyword.get(meta, :line, 0) in [0, 1]
-
       _ ->
         :ok
     end)
   end
 
   defp assert_eval(expected, actual, binding \\ []) do
-    result = EEx.eval_string(actual, binding, file: __ENV__.file, engine: EEx.SmartEngine)
+    result = EEx.eval_string(actual, binding, file: __ENV__.file)
     assert result == expected
   end
 end

lib/eex/test/eex/tokenizer_test.exs

@@ -1,4 +1,4 @@
-Code.require_file("../test_helper.exs", __DIR__)
+Code.require_file "../test_helper.exs", __DIR__
 
 defmodule EEx.TokenizerTest do
   use ExUnit.Case, async: true
@@ -13,102 +13,86 @@ defmodule EEx.TokenizerTest do
   end
 
   test "strings with embedded code" do
-    assert T.tokenize('foo <% bar %>', 1) == {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
+    assert T.tokenize('foo <% bar %>', 1) ==
+           {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
   end
 
   test "strings with embedded equals code" do
-    assert T.tokenize('foo <%= bar %>', 1) == {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
-  end
-
-  test "strings with embedded slash code" do
-    assert T.tokenize('foo <%/ bar %>', 1) == {:ok, [{:text, 'foo '}, {:expr, 1, '/', ' bar '}]}
-  end
-
-  test "strings with embedded pipe code" do
-    assert T.tokenize('foo <%| bar %>', 1) == {:ok, [{:text, 'foo '}, {:expr, 1, '|', ' bar '}]}
+    assert T.tokenize('foo <%= bar %>', 1) ==
+           {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
   end
 
   test "strings with more than one line" do
-    assert T.tokenize('foo\n<%= bar %>', 1) == {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar '}]}
+    assert T.tokenize('foo\n<%= bar %>', 1) ==
+           {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar '}]}
   end
 
   test "strings with more than one line and expression with more than one line" do
     string = '''
-    foo <%= bar
+foo <%= bar
 
-    baz %>
-    <% foo %>
-    '''
+baz %>
+<% foo %>
+'''
 
-    exprs = [
+    assert T.tokenize(string, 1) == {:ok, [
       {:text, 'foo '},
       {:expr, 1, '=', ' bar\n\nbaz '},
       {:text, '\n'},
       {:expr, 4, '', ' foo '},
       {:text, '\n'}
-    ]
-
-    assert T.tokenize(string, 1) == {:ok, exprs}
+    ]}
   end
 
   test "quotation" do
-    assert T.tokenize('foo <%% true %>', 1) == {:ok, [{:text, 'foo <% true %>'}]}
+    assert T.tokenize('foo <%% true %>', 1) == {:ok, [
+      {:text, 'foo <% true %>'}
+    ]}
   end
 
   test "quotation with do/end" do
-    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) ==
-             {:ok, [{:text, 'foo <% true do %>bar<% end %>'}]}
+    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == {:ok, [
+      {:text, 'foo <% true do %>bar<% end %>'}
+    ]}
   end
 
   test "quotation with interpolation" do
-    exprs = [
+    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, [
       {:text, 'a <% b '},
       {:expr, 1, '=', ' c '},
       {:text, ' '},
       {:expr, 1, '=', ' d '},
       {:text, ' e %> f'}
-    ]
+    ]}
 
-    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, exprs}
-  end
-
-  test "improperly formatted quotation with interpolation" do
-    exprs = [
+    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, [
       {:text, '<%% a <%= b %> c %>'}
-    ]
-
-    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "comments" do
-    exprs = [
+    assert T.tokenize('foo <%# true %>', 1) == {:ok, [
       {:text, 'foo '}
-    ]
-
-    assert T.tokenize('foo <%# true %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "comments with do/end" do
-    exprs = [
+    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, [
       {:text, 'foo bar'}
-    ]
-
-    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "strings with embedded do end" do
-    exprs = [
+    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, [
       {:text, 'foo '},
       {:start_expr, 1, '', ' if true do '},
       {:text, 'bar'},
       {:end_expr, 1, '', ' end '}
-    ]
-
-    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "strings with embedded -> end" do
-    exprs = [
+    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
       {:start_expr, 1, '', ' cond do '},
       {:middle_expr, 1, '', ' false -> '},
@@ -116,65 +100,51 @@ defmodule EEx.TokenizerTest do
       {:middle_expr, 1, '', ' true -> '},
       {:text, 'baz'},
       {:end_expr, 1, '', ' end '}
-    ]
-
-    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) ==
-             {:ok, exprs}
+    ]}
   end
 
   test "strings with embedded keywords blocks" do
-    exprs = [
+    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, [
       {:text, 'foo '},
       {:start_expr, 1, '', ' if true do '},
       {:text, 'bar'},
       {:middle_expr, 1, '', ' else '},
       {:text, 'baz'},
       {:end_expr, 1, '', ' end '}
-    ]
-
-    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode" do
     template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  '
-
-    exprs = [
+    assert T.tokenize(template, 1, trim: true) == {:ok, [
       {:start_expr, 1, '=', ' if true do '},
       {:text, ' TRUE \n'},
       {:middle_expr, 3, '', ' else '},
       {:text, ' FALSE \n'},
       {:end_expr, 5, '', ' end '}
-    ]
-
-    assert T.tokenize(template, 1, trim: true) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode with comment" do
-    exprs = [
+    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, [
       {:text, '123'}
-    ]
-
-    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode with CRLF" do
-    exprs = [
+    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, [
       {:text, '0\r\n'},
       {:expr, 2, '=', ' 12 '},
       {:text, '34'}
-    ]
-
-    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode set to false" do
-    exprs = [
+    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, [
       {:text, ' '},
       {:expr, 1, '=', ' 12 '},
       {:text, ' \n'}
-    ]
-
-    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, exprs}
+    ]}
   end
 
   test "trim mode no false positives" do

lib/eex/test/eex_test.exs

@@ -1,36 +1,39 @@
-Code.require_file("test_helper.exs", __DIR__)
+Code.require_file "test_helper.exs", __DIR__
 
 require EEx
 
 defmodule EExTest.Compiled do
   def before_compile do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
-  EEx.function_from_string(:def, :string_sample, "<%= a + b %>", [:a, :b])
+  EEx.function_from_string :def, :string_sample, "<%= a + b %>", [:a, :b]
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file(:defp, :private_file_sample, filename, [:bar])
+  EEx.function_from_file :defp, :private_file_sample, filename, [:bar]
 
   filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-  EEx.function_from_file(:def, :public_file_sample, filename, [:bar])
+  EEx.function_from_file :def, :public_file_sample, filename, [:bar]
 
   def file_sample(arg), do: private_file_sample(arg)
 
   def after_compile do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
   @file "unknown"
   def unknown do
-    {__ENV__.line, hd(tl(get_stacktrace()))}
+    fill_in_stacktrace
+    {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
-  defp get_stacktrace do
+  defp fill_in_stacktrace do
     try do
-      :erlang.error("failed")
-    rescue
-      _ -> __STACKTRACE__
+      :erlang.error "failed"
+    catch
+      :error, _ -> System.stacktrace
     end
   end
 end
@@ -50,439 +53,359 @@ defmodule EExTest do
   doctest EEx.Engine
   doctest EEx.SmartEngine
 
-  describe "evaluates" do
-    test "simple string" do
-      assert_eval("foo bar", "foo bar")
-    end
+  test "evaluates simple string" do
+    assert_eval "foo bar", "foo bar"
+  end
 
-    test "Unicode" do
-      template = """
-        • <%= "•" %> •
-        <%= "Jößé Vâlìm" %> Jößé Vâlìm
-      """
+  test "evaluates with embedded" do
+    assert_eval "foo bar", "foo <%= :bar %>"
+  end
 
-      assert_eval("  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template)
-    end
+  test "evaluates with embedded and the binding" do
+    assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
+  end
 
-    test "trim mode" do
-      string = "<%= 123 %> \n456\n  <%= 789 %>"
-      expected = "123456\n789"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with embedded do end" do
+    assert_eval "foo bar", "foo <%= if true do %>bar<% end %>"
+  end
 
-    test "trim mode with middle expression" do
-      string = """
-      <%= cond do %>
-      <% false -> %>
-        this
-      <% true -> %>
-        that
-      <% end %>
-      """
+  test "evaluates with embedded do end and eval the expression" do
+    assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
+  end
 
-      expected = "  that\n"
-      assert_eval(expected, string, [], trim: true)
-    end
+  test "evaluates with embedded do end and nested print expression" do
+    assert_eval "foo bar", "foo <%= if true do %><%= :bar %><% end %>"
+  end
 
-    test "embedded code" do
-      assert_eval("foo bar", "foo <%= :bar %>")
-    end
+  test "evaluates with embedded do end and nested expressions" do
+    assert_eval "foo bar baz", "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
+    assert Process.get(:eex_text) == 1
+  end
 
-    test "embedded code with binding" do
-      assert EEx.eval_string("foo <%= bar %>", bar: 1) == "foo 1"
-    end
+  test "evaluates with embedded middle expression" do
+    assert_eval "foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>"
+  end
 
-    test "embedded code with do end when true" do
-      assert_eval("foo bar", "foo <%= if true do %>bar<% end %>")
-    end
+  test "evaluates with embedded middle expression and eval the expression" do
+    assert_eval "foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>"
+  end
 
-    test "embedded code with do end when false" do
-      assert_eval("foo ", "foo <%= if false do %>bar<% end %>")
-    end
+  test "evaluates with nested start expression" do
+    assert_eval "foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>"
+  end
 
-    test "embedded code with do end and expression" do
-      assert_eval("foo bar", "foo <%= if true do %><%= :bar %><% end %>")
-    end
+  test "evaluates with nested middle expression" do
+    assert_eval "foo baz", "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
+  end
 
-    test "embedded code with do end and multiple expressions" do
-      assert_eval(
-        "foo bar baz",
-        "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
-      )
+  test "evaluates with parentheses after end in end token" do
+    assert_eval " 101  102  103 ", "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
+  end
 
-      assert Process.get(:eex_text) == 1
-    end
+  test "evaluates with defined variable" do
+    assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
+  end
 
-    test "embedded code with middle expression" do
-      assert_eval("foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>")
-    end
+  test "evaluates with require code" do
+    assert_eval "foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>"
+  end
 
-    test "embedded code with evaluated middle expression" do
-      assert_eval("foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>")
-    end
+  test "evaluates with end of token" do
+    assert_eval "foo bar %>", "foo bar %>"
+  end
 
-    test "embedded code with nested do end" do
-      assert_eval("foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>")
-    end
-
-    test "embedded code with nested do end with middle expression" do
-      assert_eval(
-        "foo baz",
-        "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
-      )
-    end
-
-    test "embedded code with parentheses after end in end token" do
-      assert_eval(
-        " 101  102  103 ",
-        "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
-      )
-    end
-
-    test "embedded code with variable definition" do
-      assert_eval("foo 1", "foo <% bar = 1 %><%= bar %>")
-    end
-
-    test "embedded code with require" do
-      assert_eval("foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>")
-    end
-
-    test "with end of token" do
-      assert_eval("foo bar %>", "foo bar %>")
+  test "raises a syntax error when the token is invalid" do
+    assert_raise EEx.SyntaxError, "nofile:1: missing token '%>'", fn ->
+      EEx.compile_string "foo <%= bar"
     end
   end
 
-  describe "raises syntax errors" do
-    test "when the token is invalid" do
-      assert_raise EEx.SyntaxError, "nofile:1: missing token '%>'", fn ->
-        EEx.compile_string("foo <%= bar")
-      end
-    end
-
-    test "when middle expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected middle of expression <% else %>", fn ->
-        EEx.compile_string("<% if true %> foo<% else %>bar<% end %>")
-      end
-    end
-
-    test "when end expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <% end %>")
-      end
-    end
-
-    test "when start expression is found without an end expression" do
-      msg = "nofile:2: unexpected end of string, expected a closing '<% end %>'"
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("foo\n<% if true do %>")
-      end
-    end
-
-    test "when nested end expression is found without a start expression" do
-      assert_raise EEx.SyntaxError, "nofile:1: unexpected end of expression <% end %>", fn ->
-        EEx.compile_string("foo <% if true do %><% end %><% end %>")
-      end
-    end
-
-    test "when middle expression has a modifier" do
-      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
-               EEx.compile_string("foo <%= if true do %>true<%= else %>false<% end %>")
-             end) =~ ~s[unexpected beginning of EEx tag \"<%=\" on \"<%= else %>\"]
-    end
-
-    test "when end expression has a modifier" do
-      assert ExUnit.CaptureIO.capture_io(:stderr, fn ->
-               EEx.compile_string("foo <%= if true do %>true<% else %>false<%= end %>")
-             end) =~
-               ~s[unexpected beginning of EEx tag \"<%=\" on end of expression \"<%= end %>\"]
-    end
-
-    test "when trying to use marker '/' without implementation" do
-      msg =
-        ~r/unsupported EEx syntax <%\/ %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("<%/ true %>")
-      end
-    end
-
-    test "when trying to use marker '|' without implementation" do
-      msg =
-        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        EEx.compile_string("<%| true %>")
-      end
+  test "raises a syntax error when end expression is found without a start expression" do
+    assert_raise EEx.SyntaxError, "nofile:1: unexpected token ' end '",  fn ->
+      EEx.compile_string "foo <% end %>"
     end
   end
 
-  describe "environment" do
-    test "respects line numbers" do
-      expected = """
-      foo
-      2
-      """
-
-      string = """
-      foo
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside nested expressions" do
-      expected = """
-      foo
-
-      3
-
-      5
-      """
-
-      string = """
-      foo
-      <%= if true do %>
-      <%= __ENV__.line %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside start expression" do
-      expected = """
-      foo
-
-      true
-
-      5
-      """
-
-      string = """
-      foo
-      <%= if __ENV__.line == 2 do %>
-      <%= true %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line numbers inside middle expression with ->" do
-      expected = """
-      foo
-
-      true
-
-      7
-      """
-
-      string = """
-      foo
-      <%= cond do %>
-      <% false -> %> false
-      <% __ENV__.line == 4 -> %>
-      <%= true %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects line number inside middle expressions with keywords" do
-      expected = """
-      foo
-
-      5
-
-      7
-      """
-
-      string = """
-      foo
-      <%= if false do %>
-      <%= __ENV__.line %>
-      <% else %>
-      <%= __ENV__.line %>
-      <% end %>
-      <%= __ENV__.line %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "respects files" do
-      assert_eval("sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex")
+  test "raises a syntax error when start expression is found without an end expression" do
+    assert_raise EEx.SyntaxError, "nofile:2: unexpected end of string, expected a closing '<% end %>'", fn ->
+      EEx.compile_string "foo\n<% if true do %>"
     end
   end
 
-  describe "clauses" do
-    test "inside functions" do
-      expected = """
-
-      Number 1
-
-      Number 2
-
-      Number 3
-
-      """
-
-      string = """
-      <%= Enum.map [1, 2, 3], fn x -> %>
-      Number <%= x %>
-      <% end %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "inside cond" do
-      expected = """
-      foo
-
-      true
-
-      """
-
-      string = """
-      foo
-      <%= cond do %>
-      <% false -> %> false
-      <% fn -> 1 end -> %>
-      <%= true %>
-      <% end %>
-      """
-
-      assert_eval(expected, string)
-    end
-
-    test "inside cond with do end" do
-      string = """
-      <% y = ["a", "b", "c"] %>
-      <%= cond do %>
-       <% "a" in y -> %>
-        Good
-       <% true -> %>
-        <% if true do %>true<% else %>false<% end %>
-        Bad
-      <% end %>
-      """
-
-      assert_eval("\n\n  Good\n \n", string)
+  test "raises a syntax error when nested end expression is found without a start expression" do
+    assert_raise EEx.SyntaxError, "nofile:1: unexpected token ' end '", fn ->
+      EEx.compile_string "foo <% if true do %><% end %><% end %>"
     end
   end
 
-  describe "buffers" do
-    test "unused buffers are kept out" do
-      string = """
-      <%= 123 %>
-      <% if true do %>
-        <%= 456 %>
-      <% end %>
-      <%= 789 %>
-      """
+  test "respects line numbers" do
+    expected = """
+foo
+2
+"""
 
-      assert_eval("123\n\n789\n", string)
-    end
+    string = """
+foo
+<%= __ENV__.line %>
+"""
 
-    test "inside comprehensions" do
-      string = """
-      <%= for _name <- packages || [] do %>
-      <% end %>
-      <%= all || :done %>
-      """
+    assert_eval expected, string
+  end
 
-      assert_eval("\ndone\n", string, packages: nil, all: nil)
+  test "respects line numbers inside nested expressions" do
+    expected = """
+foo
+
+3
+
+5
+"""
+
+    string = """
+foo
+<%= if true do %>
+<%= __ENV__.line %>
+<% end %>
+<%= __ENV__.line %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "respects line numbers inside start expression" do
+    expected = """
+foo
+
+true
+
+5
+"""
+
+    string = """
+foo
+<%= if __ENV__.line == 2 do %>
+<%= true %>
+<% end %>
+<%= __ENV__.line %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "respects line numbers inside middle expression with ->" do
+    expected = """
+foo
+
+true
+
+7
+"""
+
+    string = """
+foo
+<%= cond do %>
+<% false -> %> false
+<% __ENV__.line == 4 -> %>
+<%= true %>
+<% end %>
+<%= __ENV__.line %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "respects line number inside middle expressions with keywords" do
+    expected = """
+foo
+
+5
+
+7
+"""
+
+    string = """
+foo
+<%= if false do %>
+<%= __ENV__.line %>
+<% else %>
+<%= __ENV__.line %>
+<% end %>
+<%= __ENV__.line %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "respects files" do
+    assert_eval "sample.ex", "<%= __ENV__.file %>", [], file: "sample.ex"
+  end
+
+  test "properly handle functions" do
+    expected = """
+
+Number 1
+
+Number 2
+
+Number 3
+
+"""
+
+    string = """
+<%= Enum.map [1, 2, 3], fn x -> %>
+Number <%= x %>
+<% end %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "properly handle functions on the left side of clauses" do
+    expected = """
+foo
+
+true
+
+"""
+
+    string = """
+foo
+<%= cond do %>
+<% false -> %> false
+<% fn -> 1 end -> %>
+<%= true %>
+<% end %>
+"""
+
+    assert_eval expected, string
+  end
+
+  test "evaluates nested do expressions" do
+    string = """
+    <% y = ["a", "b", "c"] %>
+    <%= cond do %>
+     <% "a" in y -> %>
+      Good
+     <% true -> %>
+      <% if true do %>true<% else %>false<% end %>
+      Bad
+    <% end %>
+    """
+
+    assert_eval "\n\n  Good\n \n", string
+  end
+
+  test "evaluates expressions with buffers" do
+    string = """
+    <%= 123 %>
+    <% if true do %>
+      <%= 456 %>
+    <% end %>
+    <%= 789 %>
+    """
+
+    assert_eval "123\n\n789\n", string
+  end
+
+  test "for comprehensions" do
+    string = """
+    <%= for _name <- packages || [] do %>
+    <% end %>
+    <%= all || :done %>
+    """
+    assert_eval "\ndone\n", string, packages: nil, all: nil
+  end
+
+  test "Unicode" do
+    template = """
+      • <%= "•" %> •
+      <%= "Jößé Vâlìm" %> Jößé Vâlìm
+    """
+    result = EEx.eval_string(template)
+    assert result == "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n"
+  end
+
+  test "trim mode" do
+    string = "<%= 123 %> \n456\n  <%= 789 %>"
+    expected = "123456\n789"
+    assert_eval expected, string, [], trim: true
+  end
+
+  test "evaluates the source from a given file" do
+    filename = Path.join(__DIR__, "fixtures/eex_template.eex")
+    result = EEx.eval_file(filename)
+    assert result == "foo bar.\n"
+  end
+
+  test "evaluates the source from a given file with bindings" do
+    filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
+    result = EEx.eval_file(filename, [bar: 1])
+    assert result == "foo 1\n"
+  end
+
+  test "raises an Exception when there's an error with the given file" do
+    assert_raise File.Error, "could not read file \"non-existent.eex\": no such file or directory", fn ->
+      filename = "non-existent.eex"
+      EEx.compile_file(filename)
     end
   end
 
-  describe "from file" do
-    test "evaluates the source" do
-      filename = Path.join(__DIR__, "fixtures/eex_template.eex")
-      result = EEx.eval_file(filename)
-      assert_normalized_newline_equal("foo bar.\n", result)
-    end
-
-    test "evaluates the source with bindings" do
-      filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-      result = EEx.eval_file(filename, bar: 1)
-      assert_normalized_newline_equal("foo 1\n", result)
-    end
-
-    test "raises an Exception when file is missing" do
-      msg = "could not read file \"non-existent.eex\": no such file or directory"
-
-      assert_raise File.Error, msg, fn ->
-        filename = "non-existent.eex"
-        EEx.compile_file(filename)
-      end
-    end
-
-    test "sets external resource attribute" do
-      assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
-               [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
-    end
+  test "sets external resource attribute" do
+    assert EExTest.Compiled.__info__(:attributes)[:external_resource] ==
+           [Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")]
   end
 
-  describe "precompiled" do
-    test "from string" do
-      assert EExTest.Compiled.string_sample(1, 2) == "3"
-    end
+  test "defined from string" do
+    assert EExTest.Compiled.string_sample(1, 2) == "3"
+  end
 
-    test "from file" do
-      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.file_sample(1))
-      assert_normalized_newline_equal("foo 1\n", EExTest.Compiled.public_file_sample(1))
-    end
+  test "defined from file" do
+    assert EExTest.Compiled.file_sample(1) == "foo 1\n"
+    assert EExTest.Compiled.public_file_sample(1) == "foo 1\n"
+  end
 
-    test "from file does not affect backtrace" do
-      file = to_charlist(Path.relative_to_cwd(__ENV__.file))
+  test "defined from file do not affect backtrace" do
+    assert EExTest.Compiled.before_compile ==
+      {8,
+        {EExTest.Compiled,
+          :before_compile,
+          0,
+          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 7]
+       }
+     }
 
-      assert EExTest.Compiled.before_compile() ==
-               {7, {EExTest.Compiled, :before_compile, 0, [file: file, line: 7]}}
+    assert EExTest.Compiled.after_compile ==
+      {23,
+        {EExTest.Compiled,
+          :after_compile,
+          0,
+          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 22]
+       }
+     }
 
-      assert EExTest.Compiled.after_compile() ==
-               {21, {EExTest.Compiled, :after_compile, 0, [file: file, line: 21]}}
-
-      assert EExTest.Compiled.unknown() ==
-               {26, {EExTest.Compiled, :unknown, 0, [file: 'unknown', line: 26]}}
-    end
+    assert EExTest.Compiled.unknown ==
+      {29,
+        {EExTest.Compiled,
+          :unknown,
+          0,
+          [file: 'unknown', line: 28]
+       }
+     }
   end
 
   defmodule TestEngine do
     @behaviour EEx.Engine
 
     def init(_opts) do
-      "INIT"
+      ""
     end
 
     def handle_body(body) do
-      "BODY(#{body})"
-    end
-
-    def handle_begin(_) do
-      "BEGIN"
-    end
-
-    def handle_end(buffer) do
-      buffer <> ":END"
+      {:wrapped, body}
     end
 
     def handle_text(buffer, text) do
-      buffer <> ":TEXT(#{String.trim(text)})"
-    end
-
-    def handle_expr(buffer, "/", expr) do
-      buffer <> ":DIV(#{Macro.to_string(expr)})"
-    end
-
-    def handle_expr(buffer, "=", expr) do
-      buffer <> ":EQUAL(#{Macro.to_string(expr)})"
+      EEx.Engine.handle_text(buffer, text)
     end
 
     def handle_expr(buffer, mark, expr) do
@@ -490,41 +413,13 @@ defmodule EExTest do
     end
   end
 
-  describe "custom engines" do
-    test "text" do
-      assert_eval("BODY(INIT:TEXT(foo))", "foo", [], engine: TestEngine)
-    end
-
-    test "custom marker" do
-      assert_eval("BODY(INIT:TEXT(foo):DIV(:bar))", "foo <%/ :bar %>", [], engine: TestEngine)
-    end
-
-    test "begin/end" do
-      assert_eval(
-        ~s[BODY(INIT:TEXT(foo):EQUAL(if() do\n  "BEGIN:TEXT(this):END"\nelse\n  "BEGIN:TEXT(that):END"\nend))],
-        "foo <%= if do %>this<% else %>that<% end %>",
-        [],
-        engine: TestEngine
-      )
-    end
-
-    test "not implemented custom marker" do
-      msg =
-        ~r/unsupported EEx syntax <%| %> \(the syntax is valid but not supported by the current EEx engine\)/
-
-      assert_raise EEx.SyntaxError, msg, fn ->
-        assert_eval({:wrapped, "foo baz"}, "foo <%| :bar %>", [], engine: TestEngine)
-      end
-    end
+  test "calls handle_body" do
+    assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
   end
 
   defp assert_eval(expected, actual, binding \\ [], opts \\ []) do
-    opts = Enum.into([file: __ENV__.file, engine: opts[:engine] || EEx.Engine], opts)
+    opts = Enum.into [file: __ENV__.file, engine: EEx.Engine], opts
     result = EEx.eval_string(actual, binding, opts)
     assert result == expected
   end
-
-  defp assert_normalized_newline_equal(expected, actual) do
-    assert String.replace(expected, "\r\n", "\n") == String.replace(actual, "\r\n", "\n")
-  end
 end

lib/eex/test/test_helper.exs

@@ -1 +1 @@
-ExUnit.start(trace: "--trace" in System.argv())
+ExUnit.start [trace: "--trace" in System.argv]

lib/elixir/Emakefile

@@ -1,19 +0,0 @@
-{'src/*', [
-  warn_unused_vars,
-  warn_export_all,
-  warn_shadow_vars,
-  warn_unused_import,
-  warn_unused_function,
-  warn_bif_clash,
-  warn_unused_record,
-  warn_deprecated_function,
-  warn_obsolete_guard,
-  strict_validation,
-  warn_exported_vars,
-  %% warn_export_vars,
-  %% warn_missing_spec,
-  %% warn_untyped_record,
-  %% warnings_as_errors,
-  debug_info,
-  {outdir, "ebin/"}
-]}.

lib/elixir/docs.exs

@@ -1,91 +0,0 @@
-# Returns config for Elixir docs
-[
-  extras: Path.wildcard("lib/elixir/pages/*.md"),
-  groups_for_modules: [
-    # [Kernel, Kernel.SpecialForms],
-
-    "Basic Types": [
-      Atom,
-      Base,
-      Bitwise,
-      Calendar,
-      Calendar.ISO,
-      Date,
-      DateTime,
-      Exception,
-      Float,
-      Function,
-      Integer,
-      NaiveDateTime,
-      Record,
-      Regex,
-      String,
-      Time,
-      Tuple,
-      URI,
-      Version
-    ],
-    "Collections & Enumerables": [
-      Access,
-      Date.Range,
-      Enum,
-      Keyword,
-      List,
-      Map,
-      MapSet,
-      Range,
-      Stream
-    ],
-    "IO & System": [
-      File,
-      File.Stat,
-      File.Stream,
-      IO,
-      IO.ANSI,
-      IO.Stream,
-      OptionParser,
-      Path,
-      Port,
-      StringIO,
-      System
-    ],
-    "Modules & Code": [
-      Code,
-      Kernel.ParallelCompiler,
-      Macro,
-      Macro.Env,
-      Module
-    ],
-    "Processes & Applications": [
-      Agent,
-      Application,
-      DynamicSupervisor,
-      GenServer,
-      Node,
-      Process,
-      Registry,
-      Supervisor,
-      Task,
-      Task.Supervisor
-    ],
-    Protocols: [
-      Collectable,
-      Enumerable,
-      Inspect,
-      Inspect.Algebra,
-      Inspect.Opts,
-      List.Chars,
-      Protocol,
-      String.Chars
-    ],
-    Deprecated: [
-      Behaviour,
-      Dict,
-      GenEvent,
-      HashDict,
-      HashSet,
-      Set,
-      Supervisor.Spec
-    ]
-  ]
-]

lib/elixir/generate_app.escript

@@ -1,13 +0,0 @@
-#!/usr/bin/env escript
-%% -*- erlang -*-
-
-main([Source, Target, Version]) ->
-  {ok, [{application, Name, Props0}]} = file:consult(Source),
-  Ebin = filename:dirname(Target),
-  Files = filelib:wildcard(filename:join(Ebin, "*.beam")),
-  Mods = [list_to_atom(filename:basename(F, ".beam")) || F <- Files],
-  Props1 = lists:keyreplace(modules, 1, Props0, {modules, Mods}),
-  Props = lists:keyreplace(vsn, 1, Props1, {vsn, Version}),
-  AppDef = io_lib:format("~tp.~n", [{application, Name, Props}]),
-  ok = file:write_file(Target, AppDef),
-  io:format("Generated ~ts.app~n", [Name]).

lib/elixir/lib/access.ex

@@ -1,53 +1,27 @@
 defmodule Access do
   @moduledoc """
-  Key-based access to data structures.
+  Key-based access to data structures using the `data[key]` syntax.
 
-  Elixir supports three main key-value constructs: keywords,
-  maps, and structs. It also supports two mechanisms to access those keys:
-  by brackets (via `data[key]`) and by dot-syntax (via `data.field`).
+  Elixir provides two syntaxes for accessing values. `user[:name]`
+  is used by dynamic structures, like maps and keywords, while
+  `user.name` is used by structs. The main difference is that
+  `user[:name]` won't raise if the key `:name` is missing but
+  `user.name` will raise if there is no `:name` key.
 
-  In the next section we will briefly recap the key-value constructs and then
-  discuss the access mechanisms.
+  Besides the cases above, this module provides convenience
+  functions for accessing other structures, like `at/1` for
+  lists and `elem/1` for tuples. Those functions can be used
+  by the nested update functions in `Kernel`, such as
+  `Kernel.get_in/2`, `Kernel.put_in/3`, `Kernel.update_in/3`,
+  `Kernel.get_and_update_in/3` and friends.
 
-  ## Key-value constructs
+  ## Dynamic lookups
 
-  Elixir provides three main key-value constructs, summarized below:
-
-    * keyword lists - they are lists of two-element tuples where
-      the first element is an atom. Commonly written in the
-      `[key: value]` syntax, they support only atom keys. Keyword
-      lists are used almost exclusively to pass options to functions
-      and macros. They keep the user ordering and allow duplicate
-      keys. See the `Keyword` module.
-
-    * maps - they are the "go to" key-value data structure in Elixir.
-      They are capable of supporting billions of keys of any type. They are
-      written using the `%{key => value}` syntax and also support the
-      `%{key: value}` syntax when the keys are atoms. They do not
-      have any specified ordering and do not allow duplicate keys.
-      See the `Map` module.
-
-    * structs - they are named maps with a pre-determined set of keys.
-      They are defined with `defstruct/1` and written using the
-      `%StructName{key: value}` syntax.
-
-  ## Key-based accessors
-
-  Elixir provides two mechanisms to access data structures by key,
-  described next.
-
-  ### Bracket-based access
-
-  The `data[key]` syntax is used to access data structures with a
-  dynamic number of keys, such as keywords and maps. The key can
-  be of any type. The bracket-based access syntax returns `nil`
-  if the key does not exist:
+  Out of the box, Access works with `Keyword` and `Map`:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:a]
       1
-      iex> keywords[:c]
-      nil
 
       iex> map = %{a: 1, b: 2}
       iex> map[:a]
@@ -57,230 +31,140 @@ defmodule Access do
       iex> star_ratings[1.5]
       "★☆"
 
+  Access can be combined with `Kernel.put_in/3` to put a value
+  in a given key:
+
+      iex> map = %{a: 1, b: 2}
+      iex> put_in map[:a], 3
+      %{a: 3, b: 2}
+
   This syntax is very convenient as it can be nested arbitrarily:
 
       iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-      iex> put_in(users["john"][:age], 28)
+      iex> put_in users["john"][:age], 28
       %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-  Furthermore, the bracket-based access syntax transparently ignores
-  `nil` values. When trying to access anything on a `nil` value, `nil`
-  is returned:
+  Furthermore, Access transparently ignores `nil` values:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:c][:unknown]
       nil
 
-      iex> nil[:a]
-      nil
+  Since Access is a behaviour, it can be implemented to key-value
+  data structures. The implementation should be added to the
+  module that defines the struct being access. Access requires the
+  key comparison to be implemented using the `===` operator.
 
-  Internally, `data[key]` translates  to `Access.get(term, key, nil)`.
-  Developers interested in implementing their own key-value data
-  structures can implement the `Access` behaviour to provide the
-  bracket-based access syntax. `Access` requires the key comparison
-  to be implemented using the `===/2` operator.
+  ## Static lookups
 
-  ### Dot-based syntax
+  The Access syntax (`foo[bar]`) cannot be used to access fields in
+  structs, since structs do not implement the Access behaviour by
+  default. It is also design decision: the dynamic access lookup
+  is meant to be used for dynamic key-value structures, like maps
+  and keywords, and not by static ones like structs.
 
-  The `data.field` syntax is used exclusively to access atom fields
-  in maps and structs. If the accessed field does not exist, an error is
-  raised. This is a deliberate decision: since all of the
-  fields in a struct are pre-determined, structs support only the
-  dot-based syntax and not the access one.
+  Therefore Elixir provides a static lookup for map and structs
+  fields. Imagine a struct named `User` with name and age fields.
+  The following would raise:
 
-  Imagine a struct named `User` with a `:name` field. The following would raise:
-
-      user = %User{name: "John"}
+      user = %User{name: "john"}
       user[:name]
-      # ** (UndefinedFunctionError) undefined function User.fetch/2 (User does not implement the Access behaviour)
+      ** (UndefinedFunctionError) undefined function User.fetch/2
+         (User does not implement the Access behaviour)
 
-  Instead we should use the `user.name` syntax to access fields:
+  Structs instead use the `user.name` syntax:
 
       user.name
-      #=> "John"
+      #=> "john"
+
+  The same `user.name` syntax can also be used by `Kernel.put_in/2`
+  to for updating structs fields:
+
+      put_in user.name, "mary"
+      %User{name: "mary"}
 
   Differently from `user[:name]`, `user.name` is not extensible via
-  a behaviour and is restricted only to structs and atom keys in maps.
+  a behaviour and is restricted to only maps and structs.
 
-  ### Summing up
+  Summing up:
 
-  The bracket-based syntax, `user[:name]`, is used by dynamic structures,
-  is extensible and returns nil on misisng keys.
+    * `user[:name]` is used by dynamic structures, is extensible and
+      does not raise on missing keys
+    * `user.name` is used by static structures, it is not extensible
+      and it will raise on missing keys
 
-  The dot-based syntax, `user.name`, is used exclusively to access atom
-  keys in maps and structs, and it raises on missing keys.
+  ## Accessors
 
-  ## Nested data structures
+  While Elixir provides built-in syntax only for traversing dynamic
+  and static key-value structures, this module provides convenience
+  functions for traversing other structures, like tuples and lists,
+  to be used alongside `Kernel.put_in/2` in others.
 
-  Both key-based access syntaxes can be used with the nested update
-  functions and macros in `Kernel`, such as `Kernel.get_in/2`, `Kernel.put_in/3`,
-  `Kernel.update_in/3`, `Kernel.pop_in/2`, and `Kernel.get_and_update_in/3`.
+  For instance, given a user with a list of languages, here is how to
+  deeply traverse the map and convert all language names to uppercase:
 
-  For example, to update a map inside another map:
-
-     iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-     iex> put_in(users["john"].age, 28)
-     %{"john" => %{age: 28}, "meg" => %{age: 23}}
-
-  This module provides convenience functions for traversing other
-  structures, like tuples and lists. These functions can be used
-  in all the `Access`-related functions and macros in `Kernel`.
-
-  For instance, given a user map with the `:name` and `:languages` keys,
-  here is how to deeply traverse the map and convert all language names
-  to uppercase:
-
-      iex> languages = [
-      ...>   %{name: "elixir", type: :functional},
-      ...>   %{name: "c", type: :procedural},
-      ...> ]
-      iex> user = %{name: "john", languages: languages}
-      iex> update_in(user, [:languages, Access.all(), :name], &String.upcase/1)
+      iex> user = %{name: "john",
+      ...>          languages: [%{name: "elixir", type: :functional},
+      ...>                      %{name: "c", type: :procedural}]}
+      iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
       %{name: "john",
         languages: [%{name: "ELIXIR", type: :functional},
                     %{name: "C", type: :procedural}]}
 
-  See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for some of the
-  available accessors.
+  See the functions `key/1`, `key!/1`, `elem/1` and `all/0` for the current
+  accessors.
   """
 
-  @type container :: keyword | struct | map
-  @type nil_container :: nil
-  @type any_container :: any
-  @type t :: container | nil_container | any_container
+  @type t :: list | map | nil
   @type key :: any
   @type value :: any
 
-  @type get_fun(data, get_value) ::
-          (:get, data, (term -> term) ->
-             {get_value, new_data :: container})
+  @callback fetch(t, key) :: {:ok, value} | :error
+  @callback get(t, key, value) :: value
+  @callback get_and_update(t, key, (value -> {value, value} | :pop)) :: {value, t}
+  @callback pop(t, key) :: {value, t}
 
-  @type get_and_update_fun(data, get_value) ::
-          (:get_and_update, data, (term -> term) ->
-             {get_value, new_data :: container} | :pop)
-
-  @type access_fun(data, get_value) ::
-          get_fun(data, get_value) | get_and_update_fun(data, get_value)
-
-  @doc """
-  Invoked in order to access the value stored under `key` in the given term `term`.
-
-  This function should return `{:ok, value}` where `value` is the value under
-  `key` if the key exists in the term, or `:error` if the key does not exist in
-  the term.
-
-  Many of the functions defined in the `Access` module internally call this
-  function. This function is also used when the square-brackets access syntax
-  (`structure[key]`) is used: the `fetch/2` callback implemented by the module
-  that defines the `structure` struct is invoked and if it returns `{:ok,
-  value}` then `value` is returned, or if it returns `:error` then `nil` is
-  returned.
-
-  See the `Map.fetch/2` and `Keyword.fetch/2` implementations for examples of
-  how to implement this callback.
-  """
-  @callback fetch(term :: t, key) :: {:ok, value} | :error
-
-  @doc """
-  Invoked in order to access the value under `key` and update it at the same time.
-
-  The implementation of this callback should invoke `fun` with the value under
-  `key` in the passed structure `data`, or with `nil` if `key` is not present in it.
-  This function must return either `{get_value, update_value}` or `:pop`.
-
-  If the passed function returns `{get_value, update_value}`,
-  the return value of this callback should be `{get_value, new_data}`, where:
-
-    * `get_value` is the retrieved value (which can be operated on before being returned)
-
-    * `update_value` is the new value to be stored under `key`
-
-    * `new_data` is `data` after updating the value of `key` with `update_value`.
-
-  If the passed function returns `:pop`, the return value of this callback
-  must be `{value, new_data}` where `value` is the value under `key`
-  (or `nil` if not present) and `new_data` is `data` without `key`.
-
-  See the implementations of `Map.get_and_update/3` or `Keyword.get_and_update/3`
-  for more examples.
-  """
-  @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}
-            when get_value: var, data: container | any_container
-
-  @doc """
-  Invoked to "pop" the value under `key` out of the given data structure.
-
-  When `key` exists in the given structure `data`, the implementation should
-  return a `{value, new_data}` tuple where `value` is the value that was under
-  `key` and `new_data` is `term` without `key`.
-
-  When `key` is not present in the given structure, a tuple `{value, data}`
-  should be returned, where `value` is implementation-defined.
-
-  See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.
-  """
-  @callback pop(data, key) :: {value, data} when data: container | any_container
-
-  defmacrop raise_undefined_behaviour(exception, module, top) do
+  defmacrop raise_undefined_behaviour(e, struct, top) do
     quote do
-      exception =
-        case __STACKTRACE__ do
+      stacktrace = System.stacktrace
+      e =
+        case stacktrace do
           [unquote(top) | _] ->
-            reason = "#{inspect(unquote(module))} does not implement the Access behaviour"
-            %{unquote(exception) | reason: reason}
-
+            %{unquote(e) | reason: "#{inspect unquote(struct)} does not implement the Access behaviour"}
           _ ->
-            unquote(exception)
+            unquote(e)
         end
-
-      reraise exception, __STACKTRACE__
+      reraise e, stacktrace
     end
   end
 
   @doc """
-  Fetches the value for the given key in a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns `{:ok, value}` where `value` is the value under `key` if there is such
-  a key, or `:error` if `key` is not found.
-
-  ## Examples
-
-      iex> Access.fetch(%{name: "meg", age: 26}, :name)
-      {:ok, "meg"}
-
-      iex> Access.fetch([ordered: true, on_timeout: :exit], :timeout)
-      :error
-
+  Fetches the container's value for the given key.
   """
-  @spec fetch(container, term) :: {:ok, term} | :error
-  @spec fetch(nil_container, any) :: :error
+  @spec fetch(t, term) :: {:ok, term} | :error
   def fetch(container, key)
 
-  def fetch(%module{} = container, key) do
-    module.fetch(container, key)
+  def fetch(%{__struct__: struct} = container, key) do
+    struct.fetch(container, key)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :fetch, [^container, ^key], _}
   end
 
-  def fetch(map, key) when is_map(map) do
-    case map do
-      %{^key => value} -> {:ok, value}
-      _ -> :error
-    end
+  def fetch(%{} = map, key) do
+    :maps.find(key, map)
   end
 
   def fetch(list, key) when is_list(list) and is_atom(key) do
     case :lists.keyfind(key, 1, list) do
-      {_, value} -> {:ok, value}
+      {^key, value} -> {:ok, value}
       false -> :error
     end
   end
 
   def fetch(list, key) when is_list(list) do
     raise ArgumentError,
-          "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
+      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
   end
 
   def fetch(nil, _key) do
@@ -288,96 +172,40 @@ defmodule Access do
   end
 
   @doc """
-  Gets the value for the given key in a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns the value under `key` if there is such a key, or `default` if `key` is
-  not found.
-
-  ## Examples
-
-      iex> Access.get(%{name: "john"}, :name, "default name")
-      "john"
-      iex> Access.get(%{name: "john"}, :age, 25)
-      25
-
-      iex> Access.get([ordered: true], :timeout)
-      nil
-
+  Gets the container's value for the given key.
   """
-  @spec get(container, term, term) :: term
-  @spec get(nil_container, any, default) :: default when default: var
-  def get(container, key, default \\ nil)
-
-  # Reimplementing the same logic as Access.fetch/2 here is done for performance, since
-  # this is called a lot and calling fetch/2 means introducing some overhead (like
-  # building the "{:ok, _}" tuple and deconstructing it back right away).
-
-  def get(%module{} = container, key, default) do
-    try do
-      module.fetch(container, key)
-    rescue
-      exception in UndefinedFunctionError ->
-        raise_undefined_behaviour(exception, module, {^module, :fetch, [^container, ^key], _})
-    else
+  @spec get(t, term, term) :: term
+  def get(container, key, default \\ nil) do
+    case fetch(container, key) do
       {:ok, value} -> value
       :error -> default
     end
   end
 
-  def get(map, key, default) when is_map(map) do
-    case map do
-      %{^key => value} -> value
-      _ -> default
-    end
-  end
-
-  def get(list, key, default) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {_, value} -> value
-      false -> default
-    end
-  end
-
-  def get(list, key, _default) when is_list(list) do
-    raise ArgumentError,
-          "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
-  end
-
-  def get(nil, _key, default) do
-    default
-  end
-
   @doc """
-  Gets and updates the given key in a `container` (a map, a keyword list,
-  a struct that implements the `Access` behaviour).
+  Gets and updates the container's value for the given key, in a single pass.
 
-  The `fun` argument receives the value of `key` (or `nil` if `key` is not
-  present in `container`) and must return a two-element tuple `{get_value, update_value}`:
-  the "get" value `get_value` (the retrieved value, which can be operated on before
-  being returned) and the new value to be stored under `key` (`update_value`).
-  `fun` may also return `:pop`, which means the current value
-  should be removed from the container and returned.
+  This `fun` argument receives the value of `key` (or `nil` if `key`
+  is not present) and must return a two-element tuple: the "get" value
+  (the retrieved value, which can be operated on before being returned)
+  and the new value to be stored under `key`. The `fun` may also
+  return `:pop`, implying the current value shall be removed
+  from the map and returned.
 
-  The returned value is a two-element tuple with the "get" value returned by
-  `fun` and a new container with the updated value under `key`.
+  The returned value is a tuple with the "get" value returned by
+  `fun` and a new map with the updated value under `key`.
   """
-  @spec get_and_update(data, key, (value -> {get_value, value} | :pop)) :: {get_value, data}
-        when get_value: var, data: container
+  @spec get_and_update(t, key, (value -> {get, value})) :: {get, t} when get: var
   def get_and_update(container, key, fun)
 
-  def get_and_update(%module{} = container, key, fun) do
-    module.get_and_update(container, key, fun)
+  def get_and_update(%{__struct__: struct} = container, key, fun) do
+    struct.get_and_update(container, key, fun)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(
-        exception,
-        module,
-        {^module, :get_and_update, [^container, ^key, ^fun], _}
-      )
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :get_and_update, [^container, ^key, ^fun], _}
   end
 
-  def get_and_update(map, key, fun) when is_map(map) do
+  def get_and_update(%{} = map, key, fun) do
     Map.get_and_update(map, key, fun)
   end
 
@@ -386,105 +214,67 @@ defmodule Access do
   end
 
   def get_and_update(nil, key, _fun) do
-    raise ArgumentError, "could not put/update key #{inspect(key)} on a nil value"
+    raise ArgumentError,
+      "could not put/update key #{inspect key} on a nil value"
   end
 
-  @doc """
-  Removes the entry with a given key from a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns a tuple containing the value associated with the key and the
-  updated container. `nil` is returned for the value if the key isn't
-  in the container.
-
-  ## Examples
-
-  With a map:
-
-      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :name)
-      {"Elixir", %{creator: "Valim"}}
-
-  A keyword list:
-
-      iex> Access.pop([name: "Elixir", creator: "Valim"], :name)
-      {"Elixir", [creator: "Valim"]}
-
-  An unknown key:
-
-      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :year)
-      {nil, %{creator: "Valim", name: "Elixir"}}
-
-  """
-  @spec pop(data, key) :: {value, data} when data: container
-  def pop(%module{} = container, key) do
-    module.pop(container, key)
+  def pop(%{__struct__: struct} = container, key) do
+    struct.pop(container, key)
   rescue
-    exception in UndefinedFunctionError ->
-      raise_undefined_behaviour(exception, module, {^module, :pop, [^container, ^key], _})
+    e in UndefinedFunctionError ->
+      raise_undefined_behaviour e, struct, {^struct, :pop, [^container, ^key], _}
   end
-
+  def pop(list, key) when is_list(list), do: Keyword.pop(list, key)
   def pop(map, key) when is_map(map) do
-    Map.pop(map, key)
+    case map do
+      %{^key => value} -> {value, :maps.remove(key, map)}
+      %{} -> {nil, map}
+    end
   end
-
-  def pop(list, key) when is_list(list) do
-    Keyword.pop(list, key)
-  end
-
   def pop(nil, key) do
-    raise ArgumentError, "could not pop key #{inspect(key)} on a nil value"
+    raise ArgumentError,
+      "could not pop key #{inspect key} on a nil value"
   end
 
   ## Accessors
 
   @doc """
-  Returns a function that accesses the given key in a map/struct.
+  Accesses the given key in a map/struct.
 
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  The returned function uses the default value if the key does not exist.
-  This can be used to specify defaults and safely traverse missing keys:
-
-      iex> get_in(%{}, [Access.key(:user, %{name: "meg"}), Access.key(:name)])
-      "meg"
-
-  Such is also useful when using update functions, allowing us to introduce
-  values as we traverse the data structure for updates:
-
-      iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], "Mary")
-      %{user: %{name: "Mary"}}
+  Uses the default value if the key does not exist
+  or if the value being accessed is `nil`.
 
   ## Examples
 
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, "john")])
+      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name)])
+      nil
+      iex> get_in(%{}, [Access.key(:unknown, %{name: "john"}), Access.key(:name)])
       "john"
-      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name, "john")])
+      "john"
+
+      iex> map = %{user: %{name: "john"}}
+      iex> get_in(map, [Access.key(:unknown), Access.key(:name, "john")])
+      "john"
+      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: %{name: "JOHN"}}}
       iex> pop_in(map, [Access.key(:user), Access.key(:name)])
       {"john", %{user: %{}}}
 
-  An error is raised if the accessed structure is not a map or a struct:
-
-      iex> get_in(nil, [Access.key(:foo)])
-      ** (BadMapError) expected a map, got: nil
+  An error is raised if the accessed structure is not a map/struct/nil:
 
       iex> get_in([], [Access.key(:foo)])
-      ** (BadMapError) expected a map, got: []
+      ** (RuntimeError) Access.key/1 expected a map/struct or nil, got: []
 
   """
-  @spec key(key, term) :: access_fun(data :: struct | map, get_value :: term)
   def key(key, default \\ nil) do
     fn
       :get, data, next ->
-        next.(Map.get(data, key, default))
-
+        next.(Map.get(to_map(data), key, default))
       :get_and_update, data, next ->
-        value = Map.get(data, key, default)
-
+        value = Map.get(to_map(data), key, default)
         case next.(value) do
           {get, update} -> {get, Map.put(data, key, update)}
           :pop -> {value, Map.delete(data, key)}
@@ -492,21 +282,22 @@ defmodule Access do
     end
   end
 
+  defp to_map(nil), do: %{}
+  defp to_map(%{} = map), do: map
+  defp to_map(data), do: raise "Access.key/1 expected a map/struct or nil, got: #{inspect data}"
+
   @doc """
-  Returns a function that accesses the given key in a map/struct.
+  Accesses the given key in a map/struct.
 
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  Similar to `key/2`, but the returned function raises if the key does not exist.
+  Raises if the key does not exist.
 
   ## Examples
 
       iex> map = %{user: %{name: "john"}}
       iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
       "john"
-      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: %{name: "JOHN"}}}
       iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
@@ -520,43 +311,33 @@ defmodule Access do
       ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
 
   """
-  @spec key!(key) :: access_fun(data :: struct | map, get_value :: term)
   def key!(key) do
     fn
       :get, %{} = data, next ->
         next.(Map.fetch!(data, key))
-
       :get_and_update, %{} = data, next ->
         value = Map.fetch!(data, key)
-
         case next.(value) do
           {get, update} -> {get, Map.put(data, key, update)}
           :pop -> {value, Map.delete(data, key)}
         end
-
       _op, data, _next ->
-        raise "Access.key!/1 expected a map/struct, got: #{inspect(data)}"
+        raise "Access.key!/1 expected a map/struct, got: #{inspect data}"
     end
   end
 
   @doc ~S"""
-  Returns a function that accesses the element at the given index in a tuple.
+  Accesses the element at the given index in a tuple.
 
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  The returned function raises if `index` is out of bounds.
-
-  Note that popping elements out of tuples is not possible and raises an
-  error.
+  Raises if the index is out of bounds.
 
   ## Examples
 
       iex> map = %{user: {"john", 27}}
       iex> get_in(map, [:user, Access.elem(0)])
       "john"
-      iex> get_and_update_in(map, [:user, Access.elem(0)], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(map, [:user, Access.elem(0)], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", %{user: {"JOHN", 27}}}
       iex> pop_in(map, [:user, Access.elem(0)])
@@ -568,51 +349,44 @@ defmodule Access do
       ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
 
   """
-  @spec elem(non_neg_integer) :: access_fun(data :: tuple, get_value :: term)
-  def elem(index) when is_integer(index) and index >= 0 do
+  def elem(index) when is_integer(index) do
     pos = index + 1
 
     fn
       :get, data, next when is_tuple(data) ->
         next.(:erlang.element(pos, data))
-
       :get_and_update, data, next when is_tuple(data) ->
         value = :erlang.element(pos, data)
-
         case next.(value) do
           {get, update} -> {get, :erlang.setelement(pos, data, update)}
           :pop -> raise "cannot pop data from a tuple"
         end
-
       _op, data, _next ->
-        raise "Access.elem/1 expected a tuple, got: #{inspect(data)}"
+        raise "Access.elem/1 expected a tuple, got: #{inspect data}"
     end
   end
 
   @doc ~S"""
-  Returns a function that accesses all the elements in a list.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
+  Accesses all the elements in a list.
 
   ## Examples
 
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.all(), :name])
       ["john", "mary"]
-      iex> get_and_update_in(list, [Access.all(), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.all(), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
       iex> pop_in(list, [Access.all(), :name])
       {["john", "mary"], [%{}, %{}]}
 
   Here is an example that traverses the list dropping even
-  numbers and multiplying odd numbers by 2:
+  numbers and multipling odd numbers by 2:
 
       iex> require Integer
-      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn num ->
-      ...>   if Integer.is_even(num), do: :pop, else: {num, num * 2}
+      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn
+      ...>   num -> if Integer.is_even(num), do: :pop, else: {num, num * 2}
       ...> end)
       {[1, 2, 3, 4, 5], [2, 6, 10]}
 
@@ -622,7 +396,6 @@ defmodule Access do
       ** (RuntimeError) Access.all/0 expected a list, got: %{}
 
   """
-  @spec all() :: access_fun(data :: list, get_value :: list)
   def all() do
     &all/3
   end
@@ -632,11 +405,11 @@ defmodule Access do
   end
 
   defp all(:get_and_update, data, next) when is_list(data) do
-    all(data, next, _gets = [], _updates = [])
+    all(data, next, [], [])
   end
 
   defp all(_op, data, _next) do
-    raise "Access.all/0 expected a list, got: #{inspect(data)}"
+    raise "Access.all/0 expected a list, got: #{inspect data}"
   end
 
   defp all([head | rest], next, gets, updates) do
@@ -651,27 +424,17 @@ defmodule Access do
   end
 
   @doc ~S"""
-  Returns a function that accesses the element at `index` (zero based) of a list.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
+  Accesses the element at `index` (zero based) of a list.
 
   ## Examples
 
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.at(1), :name])
       "mary"
-      iex> get_and_update_in(list, [Access.at(0), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.at(0), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {"john", [%{name: "JOHN"}, %{name: "mary"}]}
-
-  `at/1` can also be used to pop elements out of a list or
-  a key inside of a list:
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> pop_in(list, [Access.at(0)])
-      {%{name: "john"}, [%{name: "mary"}]}
       iex> pop_in(list, [Access.at(0), :name])
       {"john", [%{}, %{name: "mary"}]}
 
@@ -680,8 +443,8 @@ defmodule Access do
       iex> list = [%{name: "john"}, %{name: "mary"}]
       iex> get_in(list, [Access.at(10), :name])
       nil
-      iex> get_and_update_in(list, [Access.at(10), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
+      iex> get_and_update_in(list, [Access.at(10), :name], fn
+      ...>   prev -> {prev, String.upcase(prev)}
       ...> end)
       {nil, [%{name: "john"}, %{name: "mary"}]}
 
@@ -694,11 +457,9 @@ defmodule Access do
 
       iex> get_in(%{}, [Access.at(1)])
       ** (RuntimeError) Access.at/1 expected a list, got: %{}
-
   """
-  @spec at(non_neg_integer) :: access_fun(data :: list, get_value :: term)
-  def at(index) when is_integer(index) and index >= 0 do
-    fn op, data, next -> at(op, data, index, next) end
+  def at(index) when index >= 0 do
+    fn(op, data, next) -> at(op, data, index, next) end
   end
 
   defp at(:get, data, index, next) when is_list(data) do
@@ -710,13 +471,13 @@ defmodule Access do
   end
 
   defp at(_op, data, _index, _next) do
-    raise "Access.at/1 expected a list, got: #{inspect(data)}"
+    raise "Access.at/1 expected a list, got: #{inspect data}"
   end
 
   defp get_and_update_at([head | rest], 0, next, updates) do
     case next.(head) do
       {get, update} -> {get, :lists.reverse([update | updates], rest)}
-      :pop -> {head, :lists.reverse(updates, rest)}
+      :pop -> {head, :lists.reverse([head | updates], rest)}
     end
   end
 
@@ -727,86 +488,4 @@ defmodule Access do
   defp get_and_update_at([], _index, _next, updates) do
     {nil, :lists.reverse(updates)}
   end
-
-  @doc ~S"""
-  Returns a function that accesses all elements of a list that match the provided predicate.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  ## Examples
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> get_in(list, [Access.filter(&(&1.salary > 20)), :name])
-      ["francine"]
-      iex> get_and_update_in(list, [Access.filter(&(&1.salary <= 20)), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {["john"], [%{name: "JOHN", salary: 10}, %{name: "francine", salary: 30}]}
-
-  `filter/1` can also be used to pop elements out of a list or
-  a key inside of a list:
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> pop_in(list, [Access.filter(&(&1.salary >= 20))])
-      {[%{name: "francine", salary: 30}], [%{name: "john", salary: 10}]}
-      iex> pop_in(list, [Access.filter(&(&1.salary >= 20)), :name])
-      {["francine"], [%{name: "john", salary: 10}, %{salary: 30}]}
-
-  When no match is found, an empty list is returned and the update function is never called
-
-      iex> list = [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]
-      iex> get_in(list, [Access.filter(&(&1.salary >= 50)), :name])
-      []
-      iex> get_and_update_in(list, [Access.filter(&(&1.salary >= 50)), :name], fn prev ->
-      ...>   {prev, String.upcase(prev)}
-      ...> end)
-      {[], [%{name: "john", salary: 10}, %{name: "francine", salary: 30}]}
-
-  An error is raised if the predicate is not a function or is of the incorrect arity:
-
-      iex> get_in([], [Access.filter(5)])
-      ** (FunctionClauseError) no function clause matching in Access.filter/1
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.filter(fn a -> a == 10 end)])
-      ** (RuntimeError) Access.filter/1 expected a list, got: %{}
-
-  """
-  @doc since: "1.6.0"
-  @spec filter((term -> boolean)) :: access_fun(data :: list, get_value :: list)
-  def filter(func) when is_function(func) do
-    fn op, data, next -> filter(op, data, func, next) end
-  end
-
-  defp filter(:get, data, func, next) when is_list(data) do
-    data |> Enum.filter(func) |> Enum.map(next)
-  end
-
-  defp filter(:get_and_update, data, func, next) when is_list(data) do
-    get_and_update_filter(data, func, next, [], [])
-  end
-
-  defp filter(_op, data, _func, _next) do
-    raise "Access.filter/1 expected a list, got: #{inspect(data)}"
-  end
-
-  defp get_and_update_filter([head | rest], func, next, updates, gets) do
-    if func.(head) do
-      case next.(head) do
-        {get, update} ->
-          get_and_update_filter(rest, func, next, [update | updates], [get | gets])
-
-        :pop ->
-          get_and_update_filter(rest, func, next, updates, [head | gets])
-      end
-    else
-      get_and_update_filter(rest, func, next, [head | updates], gets)
-    end
-  end
-
-  defp get_and_update_filter([], _func, _next, updates, gets) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
-  end
 end

lib/elixir/lib/agent.ex

@@ -6,19 +6,17 @@ defmodule Agent do
   must be accessed from different processes or by the same process
   at different points in time.
 
-  The `Agent` module provides a basic server implementation that
+  The Agent module provides a basic server implementation that
   allows state to be retrieved and updated via a simple API.
 
   ## Examples
 
   For example, in the Mix tool that ships with Elixir, we need
   to keep a set of all tasks executed by a given project. Since
-  this set is shared, we can implement it with an agent:
+  this set is shared, we can implement it with an Agent:
 
       defmodule Mix.TasksServer do
-        use Agent
-
-        def start_link(_) do
+        def start_link do
           Agent.start_link(fn -> MapSet.new end, name: __MODULE__)
         end
 
@@ -44,11 +42,12 @@ defmodule Agent do
         end
       end
 
-  Agents provide a segregation between the client and server APIs (similar
-  to GenServers). In particular, the anonymous functions given to the `Agent`
-  are executed inside the agent (the server). This distinction is important
-  because you may want to avoid expensive operations inside the agent,
-  as they will effectively block the agent until the request is fulfilled.
+  Note that agents still provide a segregation between the
+  client and server APIs, as seen in GenServers. In particular,
+  all code inside the function passed to the agent is executed
+  by the agent. This distinction is important because you may
+  want to avoid expensive operations inside the agent, as it will
+  effectively block the agent until the request is fulfilled.
 
   Consider these two examples:
 
@@ -62,36 +61,16 @@ defmodule Agent do
         Agent.get(agent, &(&1)) |> do_something_expensive()
       end
 
-  The first function blocks the agent. The second function copies all the state
-  to the client and then executes the operation in the client. One aspect to
-  consider is whether the data is large enough to require processing in the server,
-  at least initially, or small enough to be sent to the client cheaply. Another
-  factor is whether the data needs to be processed atomically: getting the
-  state and calling `do_something_expensive(state)` outside of the agent means
-  that the agent's state can be updated in the meantime. This is specially
-  important in case of updates as computing the new state in the client rather
-  than in the server can lead to race conditions if multiple clients are trying
-  to update the same state to different values.
+  The first function blocks the agent. The second function copies
+  all the state to the client and then executes the operation in the
+  client. The difference is whether the data is large enough to require
+  processing in the server, at least initially, or small enough to be
+  sent to the client cheaply.
 
-  Finally note `use Agent` defines a `child_spec/1` function, allowing the
-  defined module to be put under a supervision tree. The generated
-  `child_spec/1` can be customized with the following options:
+  ## Name Registration
 
-    * `:id` - the child specification identifier, defaults to the current module
-    * `:start` - how to start the child process (defaults to calling `__MODULE__.start_link/1`)
-    * `:restart` - when the child should be restarted, defaults to `:permanent`
-    * `:shutdown` - how to shut down the child
-
-  For example:
-
-      use Agent, restart: :transient, shutdown: 10_000
-
-  See the `Supervisor` docs for more information.
-
-  ## Name registration
-
-  An agent is bound to the same name registration rules as GenServers.
-  Read more about it in the `GenServer` documentation.
+  An Agent is bound to the same name registration rules as GenServers.
+  Read more about it in the `GenServer` docs.
 
   ## A word on distributed agents
 
@@ -116,15 +95,14 @@ defmodule Agent do
   ## Hot code swapping
 
   An agent can have its code hot swapped live by simply passing a module,
-  function, and arguments tuple to the update instruction. For example, imagine
+  function, and args tuple to the update instruction. For example, imagine
   you have an agent named `:sample` and you want to convert its inner state
-  from a keyword list to a map. It can be done with the following
+  from some dict structure to a map. It can be done with the following
   instruction:
 
       {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}
 
-  The agent's state will be added to the given list of arguments (`[%{}]`) as
-  the first argument.
+  The agent's state will be added to the given list as the first argument.
   """
 
   @typedoc "Return values of `start*` functions"
@@ -139,47 +117,13 @@ defmodule Agent do
   @typedoc "The agent state"
   @type state :: term
 
-  @doc """
-  Returns a specification to start an agent under a supervisor.
-
-  See `Supervisor`.
-  """
-  @doc since: "1.5.0"
-  def child_spec(arg) do
-    %{
-      id: Agent,
-      start: {Agent, :start_link, [arg]}
-    }
-  end
-
-  @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      @doc """
-      Returns a specification to start this module under a supervisor.
-
-      See `Supervisor`.
-      """
-      def child_spec(arg) do
-        default = %{
-          id: __MODULE__,
-          start: {__MODULE__, :start_link, [arg]}
-        }
-
-        Supervisor.child_spec(default, unquote(Macro.escape(opts)))
-      end
-
-      defoverridable child_spec: 1
-    end
-  end
-
   @doc """
   Starts an agent linked to the current process with the given function.
 
   This is often used to start the agent as part of a supervision tree.
 
-  Once the agent is spawned, the given function `fun` is invoked and its return
-  value is used as the agent state. Note that `start_link/2` does not return
+  Once the agent is spawned, the given function is invoked and its return
+  value is used as the agent state. Note that `start_link` does not return
   until the given function has returned.
 
   ## Options
@@ -200,36 +144,26 @@ defmodule Agent do
   ## Return values
 
   If the server is successfully created and initialized, the function returns
-  `{:ok, pid}`, where `pid` is the PID of the server. If an agent with the
+  `{:ok, pid}`, where `pid` is the pid of the server. If an agent with the
   specified name already exists, the function returns
-  `{:error, {:already_started, pid}}` with the PID of that process.
-
-  If the given function callback fails, the function returns `{:error, reason}`.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
-      iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
-      iex> exception
-      %RuntimeError{message: "oops"}
+  `{:error, {:already_started, pid}}` with the pid of that process.
 
+  If the given function callback fails with `reason`, the function returns
+  `{:error, reason}`.
   """
-  @spec start_link((() -> term), GenServer.options()) :: on_start
+  @spec start_link((() -> term), GenServer.options) :: on_start
   def start_link(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start_link(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent linked to the current process.
+  Starts an agent linked to the current process with the given module
+  function and arguments.
 
-  Same as `start_link/2` but a module, function, and arguments are expected
-  instead of an anonymous function; `fun` in `module` will be called with the
-  given arguments `args` to initialize the state.
+  Same as `start_link/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start_link(module, atom, [any], GenServer.options()) :: on_start
+  @spec start_link(module, atom, [any], GenServer.options) :: on_start
   def start_link(module, fun, args, options \\ []) do
     GenServer.start_link(Agent.Server, {module, fun, args}, options)
   end
@@ -238,48 +172,31 @@ defmodule Agent do
   Starts an agent process without links (outside of a supervision tree).
 
   See `start_link/2` for more information.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
   """
-  @spec start((() -> term), GenServer.options()) :: on_start
+  @spec start((() -> term), GenServer.options) :: on_start
   def start(fun, options \\ []) when is_function(fun, 0) do
     GenServer.start(Agent.Server, fun, options)
   end
 
   @doc """
-  Starts an agent without links with the given module, function, and arguments.
+  Starts an agent with the given module function and arguments.
 
-  See `start_link/4` for more information.
+  Similar to `start/2` but a module, function and args are expected
+  instead of an anonymous function.
   """
-  @spec start(module, atom, [any], GenServer.options()) :: on_start
+  @spec start(module, atom, [any], GenServer.options) :: on_start
   def start(module, fun, args, options \\ []) do
     GenServer.start(Agent.Server, {module, fun, args}, options)
   end
 
   @doc """
-  Gets an agent value via the given anonymous function.
+  Gets an agent value via the given function.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The result of the function invocation is
-  returned from this function.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
+  returned.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get(agent, (state -> a), timeout) :: a when a: var
   def get(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -289,9 +206,9 @@ defmodule Agent do
   @doc """
   Gets an agent value via the given function.
 
-  Same as `get/3` but a module, function, and arguments are expected
+  Same as `get/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec get(agent, module, atom, [term], timeout) :: any
   def get(agent, module, fun, args, timeout \\ 5000) do
@@ -299,28 +216,14 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given anonymous
-  function.
+  Gets and updates the agent state in one operation.
 
   The function `fun` is sent to the `agent` which invokes the function
   passing the agent state. The function must return a tuple with two
-  elements, the first being the value to return (that is, the "get" value)
-  and the second one being the new state of the agent.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
-      42
-      iex> Agent.get(pid, fn state -> state end)
-      43
+  elements, the first being the value to return (i.e. the `get` value)
+  and the second one is the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   """
   @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var
   def get_and_update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -328,11 +231,11 @@ defmodule Agent do
   end
 
   @doc """
-  Gets and updates the agent state in one operation via the given function.
+  Gets and updates the agent state in one operation.
 
-  Same as `get_and_update/3` but a module, function, and arguments are expected
+  Same as `get_and_update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec get_and_update(agent, module, atom, [term], timeout) :: any
   def get_and_update(agent, module, fun, args, timeout \\ 5000) do
@@ -340,28 +243,13 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state via the given anonymous function.
+  Updates the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
+  passing the agent state. The function must return the new state.
 
+  A timeout can also be specified (it has a default value of 5000).
   This function always returns `:ok`.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
-
   """
   @spec update(agent, (state -> state), timeout) :: :ok
   def update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
@@ -369,11 +257,11 @@ defmodule Agent do
   end
 
   @doc """
-  Updates the agent state via the given function.
+  Updates the agent state.
 
-  Same as `update/3` but a module, function, and arguments are expected
+  Same as `update/3` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec update(agent, module, atom, [term], timeout) :: :ok
   def update(agent, module, fun, args, timeout \\ 5000) do
@@ -381,14 +269,13 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
   The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
+  passing the agent state. The function must return the new state.
 
-  Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or
-  the node it should live on) exists.
+  Note that `cast` returns `:ok` immediately, regardless of whether the
+  destination node or agent exists.
   """
   @spec cast(agent, (state -> state)) :: :ok
   def cast(agent, fun) when is_function(fun, 1) do
@@ -396,11 +283,11 @@ defmodule Agent do
   end
 
   @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
+  Performs a cast (fire and forget) operation on the agent state.
 
-  Same as `cast/2` but a module, function, and arguments are expected
+  Same as `cast/2` but a module, function and args are expected
   instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
+  argument to the given list of args.
   """
   @spec cast(agent, module, atom, [term]) :: :ok
   def cast(agent, module, fun, args) do
@@ -408,25 +295,18 @@ defmodule Agent do
   end
 
   @doc """
-  Synchronously stops the agent with the given `reason`.
+  Stops the agent with the given `reason`.
 
-  It returns `:ok` if the agent terminates with the given
-  reason. If the agent terminates with another reason, the call will
+  It returns `:ok` if the server terminates with the given
+  reason, if it terminates with another reason, the call will
   exit.
 
   This function keeps OTP semantics regarding error reporting.
   If the reason is any other than `:normal`, `:shutdown` or
   `{:shutdown, _}`, an error report will be logged.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.stop(pid)
-      :ok
-
   """
   @spec stop(agent, reason :: term, timeout) :: :ok
   def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    GenServer.stop(agent, reason, timeout)
+    :gen.stop(agent, reason, timeout)
   end
 end

lib/elixir/lib/agent/server.ex

@@ -15,7 +15,7 @@ defmodule Agent.Server do
   def handle_call({:get_and_update, fun}, _from, state) do
     case run(fun, [state]) do
       {reply, state} -> {:reply, reply, state}
-      other -> {:stop, {:bad_return_value, other}, state}
+      other          -> {:stop, {:bad_return_value, other}, state}
     end
   end
 
@@ -23,10 +23,18 @@ defmodule Agent.Server do
     {:reply, :ok, run(fun, [state])}
   end
 
+  def handle_call(msg, from, state) do
+    super(msg, from, state)
+  end
+
   def handle_cast({:cast, fun}, state) do
     {:noreply, run(fun, [state])}
   end
 
+  def handle_cast(msg, state) do
+    super(msg, state)
+  end
+
   def code_change(_old, state, fun) do
     {:ok, run(fun, [state])}
   end
@@ -37,8 +45,8 @@ defmodule Agent.Server do
   end
 
   defp get_initial_call(fun) when is_function(fun, 0) do
-    {:module, module} = Function.info(fun, :module)
-    {:name, name} = Function.info(fun, :name)
+    {:module, module} = :erlang.fun_info(fun, :module)
+    {:name, name} = :erlang.fun_info(fun, :name)
     {module, name, 0}
   end
 

lib/elixir/lib/application.ex

@@ -2,238 +2,98 @@ defmodule Application do
   @moduledoc """
   A module for working with applications and defining application callbacks.
 
-  Applications are the idiomatic way to package software in Erlang/OTP. To get
-  the idea, they are similar to the "library" concept common in other
-  programming languages, but with some additional characteristics.
+  In Elixir (actually, in Erlang/OTP), an application is a component
+  implementing some specific functionality, that can be started and stopped
+  as a unit, and which can be re-used in other systems.
 
-  An application is a component implementing some specific functionality, with a
-  standardized directory structure, configuration, and lifecycle. Applications
-  are *loaded*, *started*, and *stopped*.
+  Applications are defined with an application file named `APP.app` where
+  `APP` is the application name, usually in `underscore_case`. The application
+  file must reside in the same `ebin` directory as the compiled modules of the
+  application.
 
-  ## The application resource file
+  In Elixir, Mix is responsible for compiling your source code and
+  generating your application `.app` file. Furthermore, Mix is also
+  responsible for configuring, starting and stopping your application
+  and its dependencies. For this reason, this documentation will focus
+  on the remaining aspects of your application: the application environment
+  and the application callback module.
 
-  Applications are specified in their [*resource
-  file*](http://erlang.org/doc/man/app.html), which is a file called `APP.app`,
-  where `APP` is the application name. For example, the application resource
-  file of the OTP application `ex_unit` is called `ex_unit.app`.
+  You can learn more about Mix generation of `.app` files by typing
+  `mix help compile.app`.
 
-  You'll find the resource file of an application in its `ebin` directory, it is
-  generated automatically by Mix. Some of its keys are taken from the keyword
-  lists returned by the `project/0` and `application/0` functions defined in
-  `mix.exs`, and others are generated by Mix itself.
+  ## Application environment
 
-  You can learn more about the generation of application resource files in the
-  documentation of `Mix.Tasks.Compile.App`, available as well by running `mix
-  help compile.app`.
+  Once an application is started, OTP provides an application environment
+  that can be used to configure the application.
 
-  ## The application environment
-
-  The key `env` of an application resource file has a list of tuples that map
-  atoms to terms, and its contents are known as the application *environment*.
-  Note that this environment is unrelated to the operating system environment.
-
-  By default, the environment of an application is an empty list. In a Mix
-  project you can set that key in `application/0`:
+  Assuming you are inside a Mix project, you can edit the `application`
+  function in the `mix.exs` file to the following:
 
       def application do
-        [env: [redis_host: "localhost"]]
+        [env: [hello: :world]]
       end
 
-  and the generated application resource file is going to have it included.
+  In the application function, we can define the default environment values
+  for our application. By starting your application with `iex -S mix`, you
+  can access the default value:
 
-  The environment is available after loading the application, which is a process
-  explained later:
+      Application.get_env(:APP_NAME, :hello)
+      #=> :world
 
-      Application.load(:APP_NAME)
-      #=> :ok
+  It is also possible to put and delete values from the application value,
+  including new values that are not defined in the environment file (although
+  this should be avoided).
 
-      Application.get_env(:APP_NAME, :redis_host)
-      #=> "localhost"
+  Keep in mind that each application is responsible for its environment.
+  Do not use the functions in this module for directly accessing or modifying
+  the environment of other applications (as it may lead to inconsistent
+  data in the application environment).
 
-  In Mix projects, the environment of the application and its dependencies can
-  be overridden via the `config/config.exs` file. If you start the application
-  with Mix, that configuration is available at compile time, and at runtime too,
-  but take into account it is not included in the generated application resource
-  file, and it is not available if you start the application without Mix.
+  ## Application module callback
 
-  For example, someone using your application can override its `:redis_host`
-  environment variable as follows:
-
-      config :APP_NAME, redis_host: "redis.local"
-
-  The function `put_env/3` allows dynamic configuration of the application
-  environment, but as a rule of thumb each application is responsible for its
-  own environment. Please do not use the functions in this module for directly
-  accessing or modifying the environment of other applications.
-
-  The application environment can be overriden via the `-config` option of
-  `erl`, as well as command-line flags, as we are going to see below.
-
-  ## The application callback module
-
-  The `mod` key of an application resource file configures an application
-  callback module and start argument:
+  Often times, an application defines a supervision tree that must be started
+  and stopped when the application starts and stops. For such, we need to
+  define an application module callback. The first step is to define the
+  module callback in the application definition in the `mix.exs` file:
 
       def application do
         [mod: {MyApp, []}]
       end
 
-  This key is optional, only needed for applications that start a supervision tree.
-
-  The `MyApp` module given to `:mod` needs to implement the `Application` behaviour.
-  This can be done by putting `use Application` in that module and implementing the
-  `c:start/2` callback, for example:
+  Our application now requires the `MyApp` module to provide an application
+  callback. This can be done by invoking `use Application` in that module and
+  defining a `start/2` callback, for example:
 
       defmodule MyApp do
         use Application
 
         def start(_type, _args) do
-          children = []
-          Supervisor.start_link(children, strategy: :one_for_one)
+          MyApp.Supervisor.start_link()
         end
       end
 
-  The `c:start/2` callback has to spawn and link a supervisor and return `{:ok,
-  pid}` or `{:ok, pid, state}`, where `pid` is the PID of the supervisor, and
-  `state` is an optional application state. `args` is the second element of the
-  tuple given to the `:mod` option.
+  `start/2` typically returns `{:ok, pid}` or `{:ok, pid, state}` where
+  `pid` identifies the supervision tree and `state` is the application state.
+  `args` is the second element of the tuple given to the `:mod` option.
 
-  The `type` argument passed to `c:start/2` is usually `:normal` unless in a
+  The `type` argument passed to `start/2` is usually `:normal` unless in a
   distributed setup where application takeovers and failovers are configured.
-  Distributed applications are beyond the scope of this documentation.
+  This particular aspect of applications is explained in more detail in the
+  OTP documentation:
 
-  When an application is shutting down, its `c:stop/1` callback is called after
-  the supervision tree has been stopped by the runtime. This callback allows the
-  application to do any final cleanup. The argument is the state returned by
-  `c:start/2`, if it did, or `[]` otherwise. The return value of `c:stop/1` is
-  ignored.
+    * [`:application` module](http://www.erlang.org/doc/man/application.html)
+    * [Applications – OTP Design Principles](http://www.erlang.org/doc/design_principles/applications.html)
 
-  By using `Application`, modules get a default implementation of `c:stop/1`
-  that ignores its argument and returns `:ok`, but it can be overridden.
-
-  Application callback modules may also implement the optional callback
-  `c:prep_stop/1`. If present, `c:prep_stop/1` is invoked before the supervision
-  tree is terminated. Its argument is the state returned by `c:start/2`, if it did,
-  or `[]` otherwise, and its return value is passed to `c:stop/1`.
-
-  ## The application lifecycle
-
-  ### Loading applications
-
-  Applications are *loaded*, which means that the runtime finds and processes
-  their resource files:
-
-      Application.load(:ex_unit)
-      #=> :ok
-
-  If an application has included applications, they are also loaded. And the
-  procedure recurses if they in turn have included applications. Included
-  applications are unrelated to applications in Mix umbrella projects, they are
-  an Erlang/OTP concept that has to do with coordinated starts.
-
-  When an application is loaded, the environment specified in its resource file
-  is merged with any overrides from config files passed to `erl` via the
-  `-config` option. It is worth highlighting that releases pass `sys.config`
-  this way. The resulting environment can still be overridden again via specific
-  `-Application` flags passed to `erl`.
-
-  Loading an application *does not* load its modules.
-
-  In practice, you rarely load applications by hand because that is part of the
-  start process, explained next.
-
-  ### Starting applications
-
-  Applications are also *started*:
-
-      Application.start(:ex_unit)
-      #=> :ok
-
-  Once your application is compiled, running your system is a matter of starting
-  your current application and its dependencies. Differently from other languages,
-  Elixir does not have a `main` procedure that is responsible for starting your
-  system. Instead, you start one or more applications, each with their own
-  initialization and termination logic.
-
-  When an application is started, the runtime loads it if it hasn't been loaded
-  yet (in the technical sense described above). Then, it checks if the
-  dependencies listed in the `applications` key of the resource file are already
-  started. Having at least one dependency not started is an error condition, but
-  when you start an application with `mix run`, Mix takes care of starting all
-  the dependencies for you, so in practice you don't need to worry about it
-  unless you are starting applications manually with the API provided by this
-  module.
-
-  If the application does not have a callback module configured, starting is
-  done at this point. Otherwise, its `c:start/2` callback if invoked. The PID of
-  the top-level supervisor returned by this function is stored by the runtime
-  for later use, and the returned application state is saved too, if any.
-
-  ### Stopping applications
-
-  Started applications are, finally, *stopped*:
-
-      Application.stop(:ex_unit)
-      #=> :ok
-
-  Stopping an application without a callback module is defined, but except for
-  some system tracing, it is in practice a no-op.
-
-  Stopping an application with a callback module has three steps:
-
-  1. If present, invoke the optional callback `c:prep_stop/1`.
-  2. Terminate the top-level supervisor.
-  3. Invoke the required callback `c:stop/1`.
-
-  The arguments passed to the callbacks are related to the state optionally
-  returned by `c:start/2`, and are documented in the section about the callback
-  module above.
-
-  It is important to highlight that step 2 is a blocking one. Termination of a
-  supervisor triggers a recursive chain of children terminations, therefore
-  orderly shutting down all descendant processes. The `c:stop/1` callback is
-  invoked only after termination of the whole supervision tree.
-
-  Shutting down a live system cleanly can be done by calling `System.stop/1`. It
-  will shut down every application in the opposite order they had been started.
-
-  From Erlang/OTP 19.1, a SIGTERM from the operating system will automatically
-  translate to `System.stop/0`. Erlang/OTP 20 gives user more explicit control
-  over OS signals via the `:os.set_signal/2` function.
-
-  ## Tooling
-
-  The Mix build tool can also be used to start your applications. For example,
-  `mix test` automatically starts your application dependencies and your application
-  itself before your test runs. `mix run --no-halt` boots your current project and
-  can be used to start a long running system. See `mix help run`.
-
-  Developers can also use tools like [Distillery](https://github.com/bitwalker/distillery)
-  that build **releases**. Releases are able to package all of your source code
-  as well as the Erlang VM into a single directory. Releases also give you explicit
-  control over how each application is started and in which order. They also provide
-  a more streamlined mechanism for starting and stopping systems, debugging, logging,
-  as well as system monitoring.
-
-  Finally, Elixir provides tools such as escripts and archives, which are
-  different mechanisms for packaging your application. Those are typically used
-  when tools must be shared between developers and not as deployment options.
-  See `mix help archive.build` and `mix help escript.build` for more detail.
-
-  ## Further information
-
-  For further details on applications please check the documentation of the
-  [`application`](http://www.erlang.org/doc/man/application.html) Erlang module,
-  and the
-  [Applications](http://www.erlang.org/doc/design_principles/applications.html)
-  section of the [OTP Design Principles User's
-  Guide](http://erlang.org/doc/design_principles/users_guide.html).
+  A developer may also implement the `stop/1` callback (automatically defined
+  by `use Application`) which does any application cleanup. It receives the
+  application state and can return any value. Note that shutting down the
+  supervisor is automatically handled by the VM.
   """
 
   @doc """
   Called when an application is started.
 
-  This function is called when an application is started using
+  This function is called when an the application is started using
   `Application.start/2` (and functions on top of that, such as
   `Application.ensure_started/2`). This function should start the top-level
   process of the application (which should be the top supervisor of the
@@ -244,7 +104,7 @@ defmodule Application do
 
     * `:normal` - used if the startup is a normal startup or if the application
       is distributed and is started on the current node because of a failover
-      from another node and the application specification key `:start_phases`
+      from another mode and the application specification key `:start_phases`
       is `:undefined`.
     * `{:takeover, node}` - used if the application is distributed and is
       started on the current node because of a failover on the node `node`.
@@ -256,58 +116,35 @@ defmodule Application do
   specification key (e.g., `mod: {MyApp, [:my_args]}`).
 
   This function should either return `{:ok, pid}` or `{:ok, pid, state}` if
-  startup is successful. `pid` should be the PID of the top supervisor. `state`
+  startup is successful. `pid` should be the pid of the top supervisor. `state`
   can be an arbitrary term, and if omitted will default to `[]`; if the
   application is later stopped, `state` is passed to the `stop/1` callback (see
-  the documentation for the `c:stop/1` callback for more information).
+  the documentation for the `stop/2` callback for more information).
 
   `use Application` provides no default implementation for the `start/2`
   callback.
   """
   @callback start(start_type, start_args :: term) ::
-              {:ok, pid}
-              | {:ok, pid, state}
-              | {:error, reason :: term}
+    {:ok, pid} |
+    {:ok, pid, state} |
+    {:error, reason :: term}
 
   @doc """
-  Called before stopping the application.
+  Called when an application is stopped.
 
-  This function is called before the top-level supervisor is terminated. It
-  receives the state returned by `c:start/2`, if it did, or `[]` otherwise.
-  The return value is later passed to `c:stop/1`.
-  """
-  @callback prep_stop(state) :: state
-
-  @doc """
-  Called after an application has been stopped.
-
-  This function is called after an application has been stopped, i.e., after its
+  This function is called when an application has stopped, i.e., when its
   supervision tree has been stopped. It should do the opposite of what the
-  `c:start/2` callback did, and should perform any necessary cleanup. The return
+  `start/2` callback did, and should perform any necessary cleanup. The return
   value of this callback is ignored.
 
-  `state` is the state returned by `c:start/2`, if it did, or `[]` otherwise.
-  If the optional callback `c:prep_stop/1` is present, `state` is its return
-  value instead.
+  `state` is the return value of the `start/2` callback or the return value of
+  the `prep_stop/1` function if the application module defines such a function.
 
   `use Application` defines a default implementation of this function which does
   nothing and just returns `:ok`.
   """
   @callback stop(state) :: term
 
-  @doc """
-  Start an application in synchronous phases.
-
-  This function is called after `start/2` finishes but before
-  `Application.start/2` returns. It will be called once for every start phase
-  defined in the application's (and any included applications') specification,
-  in the order they are listed in.
-  """
-  @callback start_phase(phase :: term, start_type, phase_args :: term) ::
-              :ok | {:error, reason :: term}
-
-  @optional_callbacks start_phase: 3, prep_stop: 1
-
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
@@ -318,7 +155,7 @@ defmodule Application do
         :ok
       end
 
-      defoverridable Application
+      defoverridable [stop: 1]
     end
   end
 
@@ -326,29 +163,17 @@ defmodule Application do
   @type key :: atom
   @type value :: term
   @type state :: term
-  @type start_type :: :normal | {:takeover, node} | {:failover, node}
-  @type restart_type :: :permanent | :transient | :temporary
+  @type start_type :: :permanent | :transient | :temporary
 
-  @application_keys [
-    :description,
-    :id,
-    :vsn,
-    :modules,
-    :maxP,
-    :maxT,
-    :registered,
-    :included_applications,
-    :applications,
-    :mod,
-    :start_phases
-  ]
+  @application_keys [:description, :id, :vsn, :modules, :maxP, :maxT, :registered,
+                     :included_applications, :applications, :mod, :start_phases]
 
   @doc """
   Returns the spec for `app`.
 
   The following keys are returned:
 
-    * #{Enum.map_join(@application_keys, "\n  * ", &"`#{inspect(&1)}`")}
+    * #{Enum.map_join @application_keys, "\n  * ", &inspect/1}
 
   Note the environment is not returned as it can be accessed via
   `fetch_env/2`. Returns `nil` if the application is not loaded.
@@ -357,7 +182,7 @@ defmodule Application do
   def spec(app) do
     case :application.get_all_key(app) do
       {:ok, info} -> :lists.keydelete(:env, 1, info)
-      :undefined -> nil
+      :undefined  -> nil
     end
   end
 
@@ -404,41 +229,6 @@ defmodule Application do
 
   If the configuration parameter does not exist, the function returns the
   `default` value.
-
-  ## Examples
-
-  `get_env/3` is commonly used to read the configuration of your OTP applications.
-  Since Mix configurations are commonly used to configure applications, we will use
-  this as a point of illustration.
-
-  Consider a new application `:my_app`. `:my_app` contains a database engine which
-  supports a pool of databases. The database engine needs to know the configuration for
-  each of those databases, and that configuration is supplied by key-value pairs in
-  environment of `:my_app`.
-
-      config :my_app, Databases.RepoOne,
-        # A database configuration
-        ip: "localhost"
-        port: 5433
-
-      config :my_app, Databases.RepoTwo,
-        # Another database configuration (for the same OTP app)
-        ip: "localhost"
-        port: 20717
-
-      config :my_app, my_app_databases: [Databases.RepoOne, Databases.RepoTwo]
-
-  Our database engine used by `:my_app` needs to know what databases exist, and
-  what the database configurations are. The database engine can make a call to
-  `get_env(:my_app, :my_app_databases)` to retrieve the list of databases (specified
-  by module names). Our database engine can then traverse each repository in the
-  list and then call `get_env(:my_app, Databases.RepoOne)` and so forth to retrieve
-  the configuration of each one.
-
-  **Important:** if you are writing a library to be used by other developers,
-  it is generally recommended to avoid the application environment, as the
-  application environment is effectively a global storage. For more information,
-  read our [library guidelines](/library-guidelines.html).
   """
   @spec get_env(app, key, value) :: value
   def get_env(app, key, default \\ nil) do
@@ -466,27 +256,11 @@ defmodule Application do
   @spec fetch_env!(app, key) :: value | no_return
   def fetch_env!(app, key) do
     case fetch_env(app, key) do
-      {:ok, value} ->
-        value
-
+      {:ok, value} -> value
       :error ->
-        vsn = :application.get_key(app, :vsn)
-        app = inspect(app)
-        key = inspect(key)
-
-        case vsn do
-          {:ok, _} ->
-            raise ArgumentError,
-                  "could not fetch application environment #{key} for application #{app} " <>
-                    "because configuration #{key} was not set"
-
-          :undefined ->
-            raise ArgumentError,
-                  "could not fetch application environment #{key} for application #{app} " <>
-                    "because the application was not loaded/started. If your application " <>
-                    "depends on #{app} at runtime, make sure to load/start it or list it " <>
-                    "under :extra_applications in your mix.exs file"
-        end
+        raise ArgumentError,
+          "application #{inspect app} is not loaded, " <>
+          "or the configuration parameter #{inspect key} is not set"
     end
   end
 
@@ -495,7 +269,7 @@ defmodule Application do
 
   ## Options
 
-    * `:timeout` - the timeout for the change (defaults to `5_000` milliseconds)
+    * `:timeout`    - the timeout for the change (defaults to 5000ms)
     * `:persistent` - persists the given value on application load and reloads
 
   If `put_env/4` is called before the application is loaded, the application
@@ -507,7 +281,7 @@ defmodule Application do
   in the application resource file on load. This means persistent values will
   stick after the application is loaded and also on application reload.
   """
-  @spec put_env(app, key, value, timeout: timeout, persistent: boolean) :: :ok
+  @spec put_env(app, key, value, [timeout: timeout, persistent: boolean]) :: :ok
   def put_env(app, key, value, opts \\ []) do
     :application.set_env(app, key, value, opts)
   end
@@ -517,7 +291,7 @@ defmodule Application do
 
   See `put_env/4` for a description of the options.
   """
-  @spec delete_env(app, key, timeout: timeout, persistent: boolean) :: :ok
+  @spec delete_env(app, key, [timeout: timeout, persistent: boolean]) :: :ok
   def delete_env(app, key, opts \\ []) do
     :application.unset_env(app, key, opts)
   end
@@ -532,7 +306,7 @@ defmodule Application do
       :ok = Application.ensure_started(:my_test_dep)
 
   """
-  @spec ensure_started(app, restart_type) :: :ok | {:error, term}
+  @spec ensure_started(app, start_type) :: :ok | {:error, term}
   def ensure_started(app, type \\ :temporary) when is_atom(app) do
     :application.ensure_started(app, type)
   end
@@ -544,7 +318,7 @@ defmodule Application do
   `:applications` in the `.app` file in case they were not previously
   started.
   """
-  @spec ensure_all_started(app, restart_type) :: {:ok, [app]} | {:error, {app, term}}
+  @spec ensure_all_started(app, start_type) :: {:ok, [app]} | {:error, {app, term}}
   def ensure_all_started(app, type \\ :temporary) when is_atom(app) do
     :application.ensure_all_started(app, type)
   end
@@ -560,7 +334,7 @@ defmodule Application do
   started before this application is. If not, `{:error, {:not_started, app}}` is
   returned, where `app` is the name of the missing application.
 
-  In case you want to automatically load **and start** all of `app`'s dependencies,
+  In case you want to automatically  load **and start** all of `app`'s dependencies,
   see `ensure_all_started/2`.
 
   The `type` argument specifies the type of the application:
@@ -583,7 +357,7 @@ defmodule Application do
   Note also that the `:transient` type is of little practical use, since when a
   supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.
   """
-  @spec start(app, restart_type) :: :ok | {:error, term}
+  @spec start(app, start_type) :: :ok | {:error, term}
   def start(app, type \\ :temporary) when is_atom(app) do
     :application.start(app, type)
   end
@@ -645,42 +419,23 @@ defmodule Application do
       #=> "bar-123"
 
   For more information on code paths, check the `Code` module in
-  Elixir and also Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html).
+  Elixir and also Erlang's `:code` module.
   """
-  @spec app_dir(app) :: String.t()
+  @spec app_dir(app) :: String.t
   def app_dir(app) when is_atom(app) do
     case :code.lib_dir(app) do
       lib when is_list(lib) -> IO.chardata_to_string(lib)
-      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect(app)}"
+      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect app}"
     end
   end
 
   @doc """
   Returns the given path inside `app_dir/1`.
-
-  If `path` is a string, then it will be used as the path inside `app_dir/1`. If
-  `path` is a list of strings, it will be joined (see `Path.join/1`) and the result
-  will be used as the path inside `app_dir/1`.
-
-  ## Examples
-
-      File.mkdir_p!("foo/ebin")
-      Code.prepend_path("foo/ebin")
-
-      Application.app_dir(:foo, "my_path")
-      #=> "foo/my_path"
-
-      Application.app_dir(:foo, ["my", "nested", "path"])
-      #=> "foo/my/nested/path"
-
   """
-  @spec app_dir(app, String.t() | [String.t()]) :: String.t()
-  def app_dir(app, path)
-
+  @spec app_dir(app, String.t | [String.t]) :: String.t
   def app_dir(app, path) when is_binary(path) do
     Path.join(app_dir(app), path)
   end
-
   def app_dir(app, path) when is_list(path) do
     Path.join([app_dir(app) | path])
   end
@@ -688,7 +443,7 @@ defmodule Application do
   @doc """
   Returns a list with information about the applications which are currently running.
   """
-  @spec started_applications(timeout) :: [{app, description :: charlist(), vsn :: charlist()}]
+  @spec started_applications(timeout) :: [tuple]
   def started_applications(timeout \\ 5000) do
     :application.which_applications(timeout)
   end
@@ -696,9 +451,9 @@ defmodule Application do
   @doc """
   Returns a list with information about the applications which have been loaded.
   """
-  @spec loaded_applications :: [{app, description :: charlist(), vsn :: charlist()}]
+  @spec loaded_applications :: [tuple]
   def loaded_applications do
-    :application.loaded_applications()
+    :application.loaded_applications
   end
 
   @doc """
@@ -706,12 +461,12 @@ defmodule Application do
   `ensure_started/2`, `stop/1`, `load/1` and `unload/1`,
   returns a string.
   """
-  @spec format_error(any) :: String.t()
+  @spec format_error(any) :: String.t
   def format_error(reason) do
     try do
       do_format_error(reason)
     catch
-      # A user could create an error that looks like a built-in one
+      # A user could create an error that looks like a builtin one
       # causing an error.
       :error, _ ->
         inspect(reason)
@@ -725,8 +480,8 @@ defmodule Application do
 
   # {:error, reason} return value
   defp do_format_error({reason, {mod, :start, args}}) do
-    Exception.format_mfa(mod, :start, args) <>
-      " returned an error: " <> Exception.format_exit(reason)
+    Exception.format_mfa(mod, :start, args) <> " returned an error: " <>
+      Exception.format_exit(reason)
   end
 
   # error or exit(reason) call, use exit reason as reason.
@@ -736,7 +491,8 @@ defmodule Application do
 
   # bad return value
   defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
-    Exception.format_mfa(mod, :start, args) <> " returned a bad value: " <> inspect(return)
+    Exception.format_mfa(mod, :start, args) <>
+      " returned a bad value: " <> inspect(return)
   end
 
   defp do_format_error({:already_started, app}) when is_atom(app) do

lib/elixir/lib/atom.ex

@@ -16,7 +16,7 @@ defmodule Atom do
       "foo"
 
   """
-  @spec to_string(atom) :: String.t()
+  @spec to_string(atom) :: String.t
   def to_string(atom) do
     :erlang.atom_to_binary(atom, :utf8)
   end
@@ -37,9 +37,8 @@ defmodule Atom do
     :erlang.atom_to_list(atom)
   end
 
-  # TODO: Remove by 2.0
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use Atom.to_charlist/1 instead"
   @spec to_char_list(atom) :: charlist
   def to_char_list(atom), do: Atom.to_charlist(atom)
 end

lib/elixir/lib/behaviour.ex

@@ -1,18 +1,13 @@
 defmodule Behaviour do
   @moduledoc """
-  Mechanism for handling behaviours.
+  This module has been deprecated.
 
-  This module is deprecated. Instead of `defcallback/1` and
-  `defmacrocallback/1`, the `@callback` and `@macrocallback`
-  module attributes can be used (respectively). See the
-  documentation for `Module` for more information on these
-  attributes.
-
-  Instead of `MyModule.__behaviour__(:callbacks)`,
-  `MyModule.behaviour_info(:callbacks)` can be used.
+  Instead of `defcallback`, one can simply use `@callback`.
+  Instead of `defmacrocallback`, one can simply use `@macrocallback`.
+  Instead of `__behaviour__(:callbacks)`, one can simply use `behaviour_info(:callbacks)`.
   """
 
-  @moduledoc deprecated: "Use @callback and @macrocallback attributes instead"
+  # TODO: Deprecate by 1.4
 
   @doc """
   Defines a function callback according to the given type specification.
@@ -25,7 +20,7 @@ defmodule Behaviour do
   Defines a macro callback according to the given type specification.
   """
   defmacro defmacrocallback(spec) do
-    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t())))
+    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t)))
   end
 
   defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
@@ -48,25 +43,21 @@ defmodule Behaviour do
     case Macro.decompose_call(spec) do
       {name, args} ->
         do_callback(kind, name, args, return, guards)
-
       _ ->
         raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
     end
   end
 
   defp do_callback(kind, name, args, return, guards) do
-    fun = fn
+    :lists.foreach fn
       {:::, _, [left, right]} ->
         ensure_not_default(left)
         ensure_not_default(right)
         left
-
       other ->
         ensure_not_default(other)
         other
-    end
-
-    :lists.foreach(fun, args)
+    end, args
 
     spec =
       quote do
@@ -74,8 +65,8 @@ defmodule Behaviour do
       end
 
     case kind do
-      :def -> quote(do: @callback(unquote(spec)))
-      :defmacro -> quote(do: @macrocallback(unquote(spec)))
+      :def -> quote(do: @callback unquote(spec))
+      :defmacro -> quote(do: @macrocallback unquote(spec))
     end
   end
 
@@ -88,33 +79,20 @@ defmodule Behaviour do
   @doc false
   defmacro __using__(_) do
     quote do
-      warning =
-        "the Behaviour module is deprecated. Instead of using this module, " <>
-          "use the @callback and @macrocallback module attributes. See the " <>
-          "documentation for Module for more information on these attributes"
-
-      IO.warn(warning)
-
       @doc false
       def __behaviour__(:callbacks) do
         __MODULE__.behaviour_info(:callbacks)
       end
 
       def __behaviour__(:docs) do
-        {:docs_v1, _, :elixir, _, _, _, docs} = Code.fetch_docs(__MODULE__)
-
-        for {{kind, name, arity}, line, _, doc, _} <- docs, kind in [:callback, :macrocallback] do
+        for {tuple, line, kind, docs} <- Code.get_docs(__MODULE__, :callback_docs) do
           case kind do
-            :callback -> {{name, arity}, line, :def, __behaviour__doc_value(doc)}
-            :macrocallback -> {{name, arity}, line, :defmacro, __behaviour__doc_value(doc)}
+            :callback -> {tuple, line, :def, docs}
+            :macrocallback -> {tuple, line, :defmacro, docs}
           end
         end
       end
 
-      defp __behaviour__doc_value(:none), do: nil
-      defp __behaviour__doc_value(:hidden), do: false
-      defp __behaviour__doc_value(%{"en" => doc}), do: doc
-
       import unquote(__MODULE__)
     end
   end

lib/elixir/lib/bitwise.ex

@@ -6,16 +6,16 @@ defmodule Bitwise do
   operators. For example:
 
       iex> use Bitwise
-      iex> bnot(1) # named
+      iex> bnot 1   # named
       -2
-      iex> 1 &&& 1 # operator
+      iex> 1 &&& 1  # operator
       1
 
   If you prefer to use only operators or skip them, you can
   pass the following options:
 
-    * `:only_operators` - includes only operators
-    * `:skip_operators` - skips operators
+    * `:only_operators` - include only operators
+    * `:skip_operators` - skip operators
 
   For example:
 
@@ -29,10 +29,7 @@ defmodule Bitwise do
   All bitwise macros can be used in guards:
 
       iex> use Bitwise
-      iex> odd? = fn
-      ...>   int when band(int, 1) == 1 -> true
-      ...>   _ -> false
-      ...> end
+      iex> odd? = fn int when band(int, 1) == 1 -> true; _ -> false end
       iex> odd?.(1)
       true
 
@@ -40,17 +37,14 @@ defmodule Bitwise do
 
   @doc false
   defmacro __using__(options) do
-    except =
-      cond do
-        Keyword.get(options, :only_operators) ->
-          [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
-
-        Keyword.get(options, :skip_operators) ->
-          [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
-
-        true ->
-          []
-      end
+    except = cond do
+      Keyword.get(options, :only_operators) ->
+        [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
+      Keyword.get(options, :skip_operators) ->
+        [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
+      true ->
+        []
+    end
 
     quote do
       import Bitwise, except: unquote(except)
@@ -67,7 +61,7 @@ defmodule Bitwise do
 
   """
   defmacro bnot(expr) do
-    quote(do: :erlang.bnot(unquote(expr)))
+    quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
@@ -80,7 +74,7 @@ defmodule Bitwise do
 
   """
   defmacro ~~~expr do
-    quote(do: :erlang.bnot(unquote(expr)))
+    quote do: :erlang.bnot(unquote(expr))
   end
 
   @doc """
@@ -91,7 +85,7 @@ defmodule Bitwise do
 
   """
   defmacro band(left, right) do
-    quote(do: :erlang.band(unquote(left), unquote(right)))
+    quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
@@ -102,7 +96,7 @@ defmodule Bitwise do
 
   """
   defmacro left &&& right do
-    quote(do: :erlang.band(unquote(left), unquote(right)))
+    quote do: :erlang.band(unquote(left), unquote(right))
   end
 
   @doc """
@@ -113,7 +107,7 @@ defmodule Bitwise do
 
   """
   defmacro bor(left, right) do
-    quote(do: :erlang.bor(unquote(left), unquote(right)))
+    quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
@@ -124,7 +118,7 @@ defmodule Bitwise do
 
   """
   defmacro left ||| right do
-    quote(do: :erlang.bor(unquote(left), unquote(right)))
+    quote do: :erlang.bor(unquote(left), unquote(right))
   end
 
   @doc """
@@ -135,7 +129,7 @@ defmodule Bitwise do
 
   """
   defmacro bxor(left, right) do
-    quote(do: :erlang.bxor(unquote(left), unquote(right)))
+    quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
@@ -146,7 +140,7 @@ defmodule Bitwise do
 
   """
   defmacro left ^^^ right do
-    quote(do: :erlang.bxor(unquote(left), unquote(right)))
+    quote do: :erlang.bxor(unquote(left), unquote(right))
   end
 
   @doc """
@@ -163,7 +157,7 @@ defmodule Bitwise do
 
   """
   defmacro bsl(left, right) do
-    quote(do: :erlang.bsl(unquote(left), unquote(right)))
+    quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
@@ -180,7 +174,7 @@ defmodule Bitwise do
 
   """
   defmacro left <<< right do
-    quote(do: :erlang.bsl(unquote(left), unquote(right)))
+    quote do: :erlang.bsl(unquote(left), unquote(right))
   end
 
   @doc """
@@ -197,7 +191,7 @@ defmodule Bitwise do
 
   """
   defmacro bsr(left, right) do
-    quote(do: :erlang.bsr(unquote(left), unquote(right)))
+    quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 
   @doc """
@@ -214,6 +208,6 @@ defmodule Bitwise do
 
   """
   defmacro left >>> right do
-    quote(do: :erlang.bsr(unquote(left), unquote(right)))
+    quote do: :erlang.bsr(unquote(left), unquote(right))
   end
 end

lib/elixir/lib/calendar/date.ex

@@ -1,666 +0,0 @@
-defmodule Date do
-  @moduledoc """
-  A Date struct and functions.
-
-  The Date struct contains the fields year, month, day and calendar.
-  New dates can be built with the `new/3` function or using the
-  [`~D`](`Kernel.sigil_D/2`) sigil:
-
-      iex> ~D[2000-01-01]
-      ~D[2000-01-01]
-
-  Both `new/3` and sigil return a struct where the date fields can
-  be accessed directly:
-
-      iex> date = ~D[2000-01-01]
-      iex> date.year
-      2000
-      iex> date.month
-      1
-
-  The functions on this module work with the `Date` struct as well
-  as any struct that contains the same fields as the `Date` struct,
-  such as `NaiveDateTime` and `DateTime`. Such functions expect
-  `t:Calendar.date/0` in their typespecs (instead of `t:t/0`).
-
-  Developers should avoid creating the Date structs directly
-  and instead rely on the functions provided by this module as well
-  as the ones in 3rd party calendar libraries.
-
-  ## Comparing dates
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `Date` struct fields. For proper comparison between
-  dates, use the `compare/2` function.
-
-  ## Using epochs
-
-  The `add/2` and `diff/2` functions can be used for computing dates
-  or retrieving the number of days between instants. For example, if there
-  is an interest in computing the number of days from the Unix epoch
-  (1970-01-01):
-
-      iex> Date.diff(~D[2010-04-17], ~D[1970-01-01])
-      14716
-
-      iex> Date.add(~D[1970-01-01], 14716)
-      ~D[2010-04-17]
-
-  Those functions are optimized to deal with common epochs, such
-  as the Unix Epoch above or the Gregorian Epoch (0000-01-01).
-  """
-
-  @enforce_keys [:year, :month, :day]
-  defstruct [:year, :month, :day, calendar: Calendar.ISO]
-
-  @type t :: %Date{
-          year: Calendar.year(),
-          month: Calendar.month(),
-          day: Calendar.day(),
-          calendar: Calendar.calendar()
-        }
-
-  @doc """
-  Returns a range of dates.
-
-  A range of dates represents a discrete number of dates where
-  the first and last values are dates with matching calendars.
-
-  Ranges of dates can be either increasing (`first <= last`) or
-  decreasing (`first > last`). They are also always inclusive.
-
-  ## Examples
-
-      iex> Date.range(~D[1999-01-01], ~D[2000-01-01])
-      #DateRange<~D[1999-01-01], ~D[2000-01-01]>
-
-  A range of dates implements the `Enumerable` protocol, which means
-  functions in the `Enum` module can be used to work with
-  ranges:
-
-      iex> range = Date.range(~D[2001-01-01], ~D[2002-01-01])
-      iex> Enum.count(range)
-      366
-      iex> Enum.member?(range, ~D[2001-02-01])
-      true
-      iex> Enum.reduce(range, 0, fn _date, acc -> acc - 1 end)
-      -366
-
-  """
-  @doc since: "1.5.0"
-  @spec range(Date.t(), Date.t()) :: Date.Range.t()
-  def range(%Date{calendar: calendar} = first, %Date{calendar: calendar} = last) do
-    {first_days, _} = to_iso_days(first)
-    {last_days, _} = to_iso_days(last)
-
-    %Date.Range{
-      first: first,
-      last: last,
-      first_in_iso_days: first_days,
-      last_in_iso_days: last_days
-    }
-  end
-
-  def range(%Date{}, %Date{}) do
-    raise ArgumentError, "both dates must have matching calendars"
-  end
-
-  @doc """
-  Returns the current date in UTC.
-
-  ## Examples
-
-      iex> date = Date.utc_today()
-      iex> date.year >= 2016
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_today(Calendar.calendar()) :: t
-  def utc_today(calendar \\ Calendar.ISO)
-
-  def utc_today(Calendar.ISO) do
-    {:ok, {year, month, day}, _, _} = Calendar.ISO.from_unix(System.os_time(), :native)
-    %Date{year: year, month: month, day: day}
-  end
-
-  def utc_today(calendar) do
-    calendar
-    |> DateTime.utc_now()
-    |> DateTime.to_date()
-  end
-
-  @doc """
-  Returns `true` if the year in the given `date` is a leap year.
-
-  ## Examples
-
-      iex> Date.leap_year?(~D[2000-01-01])
-      true
-      iex> Date.leap_year?(~D[2001-01-01])
-      false
-      iex> Date.leap_year?(~D[2004-01-01])
-      true
-      iex> Date.leap_year?(~D[1900-01-01])
-      false
-      iex> Date.leap_year?(~N[2004-01-01 01:23:45])
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec leap_year?(Calendar.date()) :: boolean()
-  def leap_year?(date)
-
-  def leap_year?(%{calendar: calendar, year: year}) do
-    calendar.leap_year?(year)
-  end
-
-  @doc """
-  Returns the number of days in the given `date` month.
-
-  ## Examples
-
-      iex> Date.days_in_month(~D[1900-01-13])
-      31
-      iex> Date.days_in_month(~D[1900-02-09])
-      28
-      iex> Date.days_in_month(~N[2000-02-20 01:23:45])
-      29
-
-  """
-  @doc since: "1.4.0"
-  @spec days_in_month(Calendar.date()) :: Calendar.day()
-  def days_in_month(date)
-
-  def days_in_month(%{calendar: calendar, year: year, month: month}) do
-    calendar.days_in_month(year, month)
-  end
-
-  @doc """
-  Returns the number of months in the given `date` year.
-
-  ## Example
-
-      iex> Date.months_in_year(~D[1900-01-13])
-      12
-
-  """
-  @doc since: "1.7.0"
-  @spec months_in_year(Calendar.date()) :: Calendar.month()
-  def months_in_year(date)
-
-  def months_in_year(%{calendar: calendar, year: year}) do
-    calendar.months_in_year(year)
-  end
-
-  @doc """
-  Builds a new ISO date.
-
-  Expects all values to be integers. Returns `{:ok, date}` if each
-  entry fits its appropriate range, returns `{:error, reason}` otherwise.
-
-  ## Examples
-
-      iex> Date.new(2000, 1, 1)
-      {:ok, ~D[2000-01-01]}
-      iex> Date.new(2000, 13, 1)
-      {:error, :invalid_date}
-      iex> Date.new(2000, 2, 29)
-      {:ok, ~D[2000-02-29]}
-
-      iex> Date.new(2000, 2, 30)
-      {:error, :invalid_date}
-      iex> Date.new(2001, 2, 29)
-      {:error, :invalid_date}
-
-  """
-  @spec new(Calendar.year(), Calendar.month(), Calendar.day(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def new(year, month, day, calendar \\ Calendar.ISO) do
-    if calendar.valid_date?(year, month, day) do
-      {:ok, %Date{year: year, month: month, day: day, calendar: calendar}}
-    else
-      {:error, :invalid_date}
-    end
-  end
-
-  @doc """
-  Converts the given date to a string according to its calendar.
-
-  ### Examples
-
-      iex> Date.to_string(~D[2000-02-28])
-      "2000-02-28"
-      iex> Date.to_string(~N[2000-02-28 01:23:45])
-      "2000-02-28"
-      iex> Date.to_string(~D[-0100-12-15])
-      "-0100-12-15"
-
-  """
-  @spec to_string(Calendar.date()) :: String.t()
-  def to_string(date)
-
-  def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.date_to_string(year, month, day)
-  end
-
-  @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  ## Examples
-
-      iex> Date.from_iso8601("2015-01-23")
-      {:ok, ~D[2015-01-23]}
-
-      iex> Date.from_iso8601("2015:01:23")
-      {:error, :invalid_format}
-
-      iex> Date.from_iso8601("2015-01-32")
-      {:error, :invalid_date}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<?-, rest::binary>>, calendar) do
-    with {:ok, %{year: year} = date} <- raw_from_iso8601(rest, calendar) do
-      {:ok, %{date | year: -year}}
-    end
-  end
-
-  def from_iso8601(<<rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar)
-  end
-
-  [match_date, guard_date, read_date] = Calendar.ISO.__match_date__()
-
-  defp raw_from_iso8601(string, calendar) do
-    with unquote(match_date) <- string,
-         true <- unquote(guard_date) do
-      {year, month, day} = unquote(read_date)
-
-      with {:ok, date} <- new(year, month, day, Calendar.ISO) do
-        convert(date, calendar)
-      end
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  @doc """
-  Parses the extended "Dates" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> Date.from_iso8601!("2015-01-23")
-      ~D[2015-01-23]
-      iex> Date.from_iso8601!("2015:01:23")
-      ** (ArgumentError) cannot parse "2015:01:23" as date, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot parse #{inspect(string)} as date, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given `date` to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `Date.to_iso8601/2` returns dates formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will raise an `ArgumentError`.
-
-  ### Examples
-
-      iex> Date.to_iso8601(~D[2000-02-28])
-      "2000-02-28"
-
-      iex> Date.to_iso8601(~D[2000-02-28], :basic)
-      "20000228"
-
-      iex> Date.to_iso8601(~N[2000-02-28 00:00:00])
-      "2000-02-28"
-
-  """
-  @spec to_iso8601(Calendar.date(), :extended | :basic) :: String.t()
-  def to_iso8601(date, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = date, format) when format in [:basic, :extended] do
-    %{year: year, month: month, day: day} = date
-    Calendar.ISO.date_to_iso8601(year, month, day, format)
-  end
-
-  def to_iso8601(%{calendar: _} = date, format) when format in [:basic, :extended] do
-    date
-    |> convert!(Calendar.ISO)
-    |> to_iso8601()
-  end
-
-  @doc """
-  Converts the given `date` to an Erlang date tuple.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will raise.
-
-  ## Examples
-
-      iex> Date.to_erl(~D[2000-01-01])
-      {2000, 1, 1}
-
-      iex> Date.to_erl(~N[2000-01-01 00:00:00])
-      {2000, 1, 1}
-
-  """
-  @spec to_erl(Calendar.date()) :: :calendar.date()
-  def to_erl(date) do
-    %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)
-    {year, month, day}
-  end
-
-  @doc """
-  Converts an Erlang date tuple to a `Date` struct.
-
-  Only supports converting dates which are in the ISO calendar,
-  or other calendars in which the days also start at midnight.
-  Attempting to convert dates from other calendars will return an error tuple.
-
-  ## Examples
-
-      iex> Date.from_erl({2000, 1, 1})
-      {:ok, ~D[2000-01-01]}
-      iex> Date.from_erl({2000, 13, 1})
-      {:error, :invalid_date}
-
-  """
-  @spec from_erl(:calendar.date(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_erl(tuple, calendar \\ Calendar.ISO)
-
-  def from_erl({year, month, day}, calendar) do
-    with {:ok, date} <- new(year, month, day, Calendar.ISO), do: convert(date, calendar)
-  end
-
-  @doc """
-  Converts an Erlang date tuple but raises for invalid dates.
-
-  ## Examples
-
-      iex> Date.from_erl!({2000, 1, 1})
-      ~D[2000-01-01]
-      iex> Date.from_erl!({2000, 13, 1})
-      ** (ArgumentError) cannot convert {2000, 13, 1} to date, reason: :invalid_date
-
-  """
-  @spec from_erl!(:calendar.date(), Calendar.calendar()) :: t
-  def from_erl!(tuple, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to date, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Compares two date structs.
-
-  Returns `:gt` if first date is later than the second
-  and `:lt` for vice versa. If the two dates are equal
-  `:eq` is returned.
-
-  ## Examples
-
-      iex> Date.compare(~D[2016-04-16], ~D[2016-04-28])
-      :lt
-
-  This function can also be used to compare across more
-  complex calendar types by considering only the date fields:
-
-      iex> Date.compare(~D[2016-04-16], ~N[2016-04-28 01:23:45])
-      :lt
-      iex> Date.compare(~D[2016-04-16], ~N[2016-04-16 01:23:45])
-      :eq
-      iex> Date.compare(~N[2016-04-16 12:34:56], ~N[2016-04-16 01:23:45])
-      :eq
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.date(), Calendar.date()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar} = date1, %{calendar: calendar} = date2) do
-    %{year: year1, month: month1, day: day1} = date1
-    %{year: year2, month: month2, day: day2} = date2
-
-    case {{year1, month1, day1}, {year2, month2, day2}} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  def compare(date1, date2) do
-    if Calendar.compatible_calendars?(date1.calendar, date2.calendar) do
-      case {to_iso_days(date1), to_iso_days(date2)} do
-        {first, second} when first > second -> :gt
-        {first, second} when first < second -> :lt
-        _ -> :eq
-      end
-    else
-      raise ArgumentError, """
-      cannot compare #{inspect(date1)} with #{inspect(date2)}.
-
-      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
-      Specify an exact time of day (using `DateTime`s) to resolve this ambiguity
-      """
-    end
-  end
-
-  @doc """
-  Converts the given `date` from its calendar to the given `calendar`.
-
-  Returns `{:ok, date}` if the calendars are compatible,
-  or `{:error, :incompatible_calendars}` if they are not.
-
-  See also `Calendar.compatible_calendars?/2`.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Date.convert(~D[2000-01-01], Calendar.Holocene)
-      {:ok, %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.date(), Calendar.calendar()) ::
-          {:ok, t} | {:error, :incompatible_calendars}
-  def convert(%{calendar: calendar, year: year, month: month, day: day}, calendar) do
-    {:ok, %Date{calendar: calendar, year: year, month: month, day: day}}
-  end
-
-  def convert(%{calendar: calendar} = date, target_calendar) do
-    if Calendar.compatible_calendars?(calendar, target_calendar) do
-      result_date =
-        date
-        |> to_iso_days()
-        |> from_iso_days(target_calendar)
-
-      {:ok, result_date}
-    else
-      {:error, :incompatible_calendars}
-    end
-  end
-
-  @doc """
-  Similar to `Date.convert/2`, but raises an `ArgumentError`
-  if the conversion between the two calendars is not possible.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Date.convert!(~D[2000-01-01], Calendar.Holocene)
-      %Date{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.date(), Calendar.calendar()) :: t
-  def convert!(date, calendar) do
-    case convert(date, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(date)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Adds the number of days to the given `date`.
-
-  The days are counted as Gregorian days. The date is returned in the same
-  calendar as it was given in.
-
-  ## Examples
-
-      iex> Date.add(~D[2000-01-03], -2)
-      ~D[2000-01-01]
-      iex> Date.add(~D[2000-01-01], 2)
-      ~D[2000-01-03]
-      iex> Date.add(~N[2000-01-01 09:00:00], 2)
-      ~D[2000-01-03]
-      iex> Date.add(~D[-0010-01-01], -2)
-      ~D[-0011-12-30]
-
-  """
-  @doc since: "1.5.0"
-  @spec add(Calendar.date(), integer()) :: t
-  def add(%{calendar: calendar} = date, days) do
-    {iso_days, fraction} = to_iso_days(date)
-    from_iso_days({iso_days + days, fraction}, calendar)
-  end
-
-  @doc """
-  Calculates the difference between two dates, in a full number of days.
-
-  It returns the number of Gregorian days between the dates. Only `Date`
-  structs that follow the same or compatible calendars can be compared
-  this way. If two calendars are not compatible, it will raise.
-
-  ## Examples
-
-      iex> Date.diff(~D[2000-01-03], ~D[2000-01-01])
-      2
-      iex> Date.diff(~D[2000-01-01], ~D[2000-01-03])
-      -2
-      iex> Date.diff(~D[0000-01-02], ~D[-0001-12-30])
-      3
-      iex> Date.diff(~D[2000-01-01], ~N[2000-01-03 09:00:00])
-      -2
-
-  """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.date(), Calendar.date()) :: integer
-  def diff(%{calendar: Calendar.ISO} = date1, %{calendar: Calendar.ISO} = date2) do
-    %{year: year1, month: month1, day: day1} = date1
-    %{year: year2, month: month2, day: day2} = date2
-
-    Calendar.ISO.date_to_iso_days(year1, month1, day1) -
-      Calendar.ISO.date_to_iso_days(year2, month2, day2)
-  end
-
-  def diff(%{calendar: calendar1} = date1, %{calendar: calendar2} = date2) do
-    if Calendar.compatible_calendars?(calendar1, calendar2) do
-      {days1, _} = to_iso_days(date1)
-      {days2, _} = to_iso_days(date2)
-      days1 - days2
-    else
-      raise ArgumentError,
-            "cannot calculate the difference between #{inspect(date1)} and #{inspect(date2)} because their calendars are not compatible and thus the result would be ambiguous"
-    end
-  end
-
-  defp to_iso_days(%{calendar: Calendar.ISO, year: year, month: month, day: day}) do
-    {Calendar.ISO.date_to_iso_days(year, month, day), {0, 86_400_000_000}}
-  end
-
-  defp to_iso_days(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.naive_datetime_to_iso_days(year, month, day, 0, 0, 0, {0, 0})
-  end
-
-  defp from_iso_days({days, _}, Calendar.ISO) do
-    {year, month, day} = Calendar.ISO.date_from_iso_days(days)
-    %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-  end
-
-  defp from_iso_days(iso_days, target_calendar) do
-    {year, month, day, _, _, _, _} = target_calendar.naive_datetime_from_iso_days(iso_days)
-    %Date{year: year, month: month, day: day, calendar: target_calendar}
-  end
-
-  @doc """
-  Calculates the day of the week of a given `date`.
-
-  Returns the day of the week as an integer. For the ISO 8601
-  calendar (the default), it is an integer from 1 to 7, where
-  1 is Monday and 7 is Sunday.
-
-  ## Examples
-
-      iex> Date.day_of_week(~D[2016-10-31])
-      1
-      iex> Date.day_of_week(~D[2016-11-01])
-      2
-      iex> Date.day_of_week(~N[2016-11-01 01:23:45])
-      2
-      iex> Date.day_of_week(~D[-0015-10-30])
-      3
-
-  """
-  @doc since: "1.4.0"
-  @spec day_of_week(Calendar.date()) :: non_neg_integer()
-  def day_of_week(date)
-
-  def day_of_week(%{calendar: calendar, year: year, month: month, day: day}) do
-    calendar.day_of_week(year, month, day)
-  end
-
-  ## Helpers
-
-  defimpl String.Chars do
-    def to_string(%{calendar: calendar, year: year, month: month, day: day}) do
-      calendar.date_to_string(year, month, day)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: Calendar.ISO, year: year, month: month, day: day}, _) do
-      "~D[" <> Calendar.ISO.date_to_string(year, month, day) <> "]"
-    end
-
-    def inspect(date, opts) do
-      Inspect.Any.inspect(date, opts)
-    end
-  end
-end

lib/elixir/lib/calendar/date_range.ex

@@ -1,132 +0,0 @@
-defmodule Date.Range do
-  @moduledoc """
-  Returns an inclusive range between dates.
-
-  Ranges must be created with the `Date.range/2` function.
-
-  The following fields are public:
-
-    * `:first` - the initial date on the range
-    * `:last` - the last date on the range
-
-  The remaining fields are private and should not be accessed.
-  """
-
-  @type t :: %__MODULE__{
-          first: Date.t(),
-          last: Date.t(),
-          first_in_iso_days: iso_days(),
-          last_in_iso_days: iso_days()
-        }
-
-  @typep iso_days() :: Calendar.iso_days()
-
-  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days]
-
-  defimpl Enumerable do
-    def member?(%{first: %{calendar: calendar}} = range, %Date{calendar: calendar} = date) do
-      %{
-        first: first,
-        last: last,
-        first_in_iso_days: first_in_iso_days,
-        last_in_iso_days: last_in_iso_days
-      } = range
-
-      %{year: first_year, month: first_month, day: first_day} = first
-      %{year: last_year, month: last_month, day: last_day} = last
-      %{year: year, month: month, day: day} = date
-      first = {first_year, first_month, first_day}
-      last = {last_year, last_month, last_day}
-      date = {year, month, day}
-
-      if first_in_iso_days <= last_in_iso_days do
-        {:ok, date >= first and date <= last}
-      else
-        {:ok, date >= last and date <= first}
-      end
-    end
-
-    def member?(_, _) do
-      {:ok, false}
-    end
-
-    def count(%{first_in_iso_days: first, last_in_iso_days: last}) do
-      {:ok, abs(first - last) + 1}
-    end
-
-    def slice(range) do
-      %{
-        first_in_iso_days: first,
-        last_in_iso_days: last,
-        first: %{calendar: calendar}
-      } = range
-
-      if first <= last do
-        {:ok, last - first + 1, &slice_asc(first + &1, &2, calendar)}
-      else
-        {:ok, first - last + 1, &slice_desc(first - &1, &2, calendar)}
-      end
-    end
-
-    defp slice_asc(current, 1, calendar), do: [date_from_iso_days(current, calendar)]
-
-    defp slice_asc(current, remaining, calendar) do
-      [date_from_iso_days(current, calendar) | slice_asc(current + 1, remaining - 1, calendar)]
-    end
-
-    defp slice_desc(current, 1, calendar), do: [date_from_iso_days(current, calendar)]
-
-    defp slice_desc(current, remaining, calendar) do
-      [date_from_iso_days(current, calendar) | slice_desc(current - 1, remaining - 1, calendar)]
-    end
-
-    def reduce(range, acc, fun) do
-      %{
-        first_in_iso_days: first_in_iso_days,
-        last_in_iso_days: last_in_iso_days,
-        first: %{calendar: calendar}
-      } = range
-
-      up? = first_in_iso_days <= last_in_iso_days
-      reduce(first_in_iso_days, last_in_iso_days, acc, fun, calendar, up?)
-    end
-
-    defp reduce(_x, _y, {:halt, acc}, _fun, _calendar, _up?) do
-      {:halted, acc}
-    end
-
-    defp reduce(x, y, {:suspend, acc}, fun, calendar, up?) do
-      {:suspended, acc, &reduce(x, y, &1, fun, calendar, up?)}
-    end
-
-    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = true) when x <= y do
-      reduce(x + 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
-    end
-
-    defp reduce(x, y, {:cont, acc}, fun, calendar, up? = false) when x >= y do
-      reduce(x - 1, y, fun.(date_from_iso_days(x, calendar), acc), fun, calendar, up?)
-    end
-
-    defp reduce(_, _, {:cont, acc}, _fun, _calendar, _up) do
-      {:done, acc}
-    end
-
-    defp date_from_iso_days(days, Calendar.ISO) do
-      {year, month, day} = Calendar.ISO.date_from_iso_days(days)
-      %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-    end
-
-    defp date_from_iso_days(days, calendar) do
-      {year, month, day, _, _, _, _} =
-        calendar.naive_datetime_from_iso_days({days, {0, 86_400_000_000}})
-
-      %Date{year: year, month: month, day: day, calendar: calendar}
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%Date.Range{first: first, last: last}, _) do
-      "#DateRange<" <> inspect(first) <> ", " <> inspect(last) <> ">"
-    end
-  end
-end

lib/elixir/lib/calendar/datetime.ex

@@ -1,997 +0,0 @@
-defmodule DateTime do
-  @moduledoc """
-  A datetime implementation with a time zone.
-
-  This datetime can be seen as an ephemeral snapshot
-  of a datetime at a given time zone. For such purposes,
-  it also includes both UTC and Standard offsets, as
-  well as the zone abbreviation field used exclusively
-  for formatting purposes.
-
-  Remember, comparisons in Elixir using `==/2`, `>/2`, `</2` and friends
-  are structural and based on the DateTime struct fields. For proper
-  comparison between datetimes, use the `compare/2` function.
-
-  The functions on this module work with the `DateTime` struct as well
-  as any struct that contains the same fields as the `DateTime` struct.
-  Such functions expect `t:Calendar.datetime/0` in their typespecs
-  (instead of `t:t/0`).
-
-  Developers should avoid creating the `DateTime` struct directly
-  and instead rely on the functions provided by this module as
-  well as the ones in 3rd party calendar libraries.
-
-  ## Where are my functions?
-
-  You will notice this module only contains conversion
-  functions as well as functions that work on UTC. This
-  is because a proper `DateTime` implementation requires a
-  time zone database which currently is not provided as part
-  of Elixir.
-
-  Such may be addressed in upcoming versions, meanwhile,
-  use 3rd party packages to provide `DateTime` building and
-  similar functionality with time zone backing.
-  """
-
-  @enforce_keys [:year, :month, :day, :hour, :minute, :second] ++
-                  [:time_zone, :zone_abbr, :utc_offset, :std_offset]
-
-  defstruct [
-    :year,
-    :month,
-    :day,
-    :hour,
-    :minute,
-    :second,
-    :time_zone,
-    :zone_abbr,
-    :utc_offset,
-    :std_offset,
-    microsecond: {0, 0},
-    calendar: Calendar.ISO
-  ]
-
-  @type t :: %__MODULE__{
-          year: Calendar.year(),
-          month: Calendar.month(),
-          day: Calendar.day(),
-          calendar: Calendar.calendar(),
-          hour: Calendar.hour(),
-          minute: Calendar.minute(),
-          second: Calendar.second(),
-          microsecond: Calendar.microsecond(),
-          time_zone: Calendar.time_zone(),
-          zone_abbr: Calendar.zone_abbr(),
-          utc_offset: Calendar.utc_offset(),
-          std_offset: Calendar.std_offset()
-        }
-
-  @unix_days :calendar.date_to_gregorian_days({1970, 1, 1})
-
-  @doc """
-  Returns the current datetime in UTC.
-
-  ## Examples
-
-      iex> datetime = DateTime.utc_now()
-      iex> datetime.time_zone
-      "Etc/UTC"
-
-  """
-  @spec utc_now(Calendar.calendar()) :: t
-  def utc_now(calendar \\ Calendar.ISO) do
-    System.os_time() |> from_unix!(:native, calendar)
-  end
-
-  @doc """
-  Converts the given Unix time to `DateTime`.
-
-  The integer can be given in different unit
-  according to `System.convert_time_unit/3` and it will
-  be converted to microseconds internally.
-
-  Unix times are always in UTC and therefore the DateTime
-  will be returned in UTC.
-
-  ## Examples
-
-      iex> {:ok, datetime} = DateTime.from_unix(1_464_096_368)
-      iex> datetime
-      #DateTime<2016-05-24 13:26:08Z>
-
-      iex> {:ok, datetime} = DateTime.from_unix(1_432_560_368_868_569, :microsecond)
-      iex> datetime
-      #DateTime<2015-05-25 13:26:08.868569Z>
-
-  The unit can also be an integer as in `t:System.time_unit/0`:
-
-      iex> {:ok, datetime} = DateTime.from_unix(143_256_036_886_856, 1024)
-      iex> datetime
-      #DateTime<6403-03-17 07:05:22.320Z>
-
-  Negative Unix times are supported, up to -62167219200 seconds,
-  which is equivalent to "0000-01-01T00:00:00Z" or 0 Gregorian seconds.
-  """
-  @spec from_unix(integer, :native | System.time_unit(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def from_unix(integer, unit \\ :second, calendar \\ Calendar.ISO) when is_integer(integer) do
-    case Calendar.ISO.from_unix(integer, unit) do
-      {:ok, {year, month, day}, {hour, minute, second}, microsecond} ->
-        iso_datetime = %DateTime{
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond,
-          std_offset: 0,
-          utc_offset: 0,
-          zone_abbr: "UTC",
-          time_zone: "Etc/UTC"
-        }
-
-        convert(iso_datetime, calendar)
-
-      {:error, _} = error ->
-        error
-    end
-  end
-
-  @doc """
-  Converts the given Unix time to `DateTime`.
-
-  The integer can be given in different unit
-  according to `System.convert_time_unit/3` and it will
-  be converted to microseconds internally.
-
-  Unix times are always in UTC and therefore the DateTime
-  will be returned in UTC.
-
-  ## Examples
-
-      # An easy way to get the Unix epoch is passing 0 to this function
-      iex> DateTime.from_unix!(0)
-      #DateTime<1970-01-01 00:00:00Z>
-
-      iex> DateTime.from_unix!(1_464_096_368)
-      #DateTime<2016-05-24 13:26:08Z>
-
-      iex> DateTime.from_unix!(1_432_560_368_868_569, :microsecond)
-      #DateTime<2015-05-25 13:26:08.868569Z>
-
-  """
-  @spec from_unix!(integer, :native | System.time_unit(), Calendar.calendar()) :: t
-  def from_unix!(integer, unit \\ :second, calendar \\ Calendar.ISO) when is_atom(unit) do
-    case from_unix(integer, unit, calendar) do
-      {:ok, datetime} ->
-        datetime
-
-      {:error, :invalid_unix_time} ->
-        raise ArgumentError, "invalid Unix time #{integer}"
-    end
-  end
-
-  @doc """
-  Converts the given `NaiveDateTime` to `DateTime`.
-
-  It expects a time zone to put the NaiveDateTime in.
-  Currently it only supports "Etc/UTC" as time zone.
-
-  ## Examples
-
-      iex> {:ok, datetime} = DateTime.from_naive(~N[2016-05-24 13:26:08.003], "Etc/UTC")
-      iex> datetime
-      #DateTime<2016-05-24 13:26:08.003Z>
-
-  """
-  @doc since: "1.4.0"
-  @spec from_naive(NaiveDateTime.t(), Calendar.time_zone()) :: {:ok, t}
-  def from_naive(naive_datetime, time_zone)
-
-  def from_naive(%NaiveDateTime{} = naive_datetime, "Etc/UTC") do
-    %{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      year: year,
-      month: month,
-      day: day
-    } = naive_datetime
-
-    datetime = %DateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      std_offset: 0,
-      utc_offset: 0,
-      zone_abbr: "UTC",
-      time_zone: "Etc/UTC"
-    }
-
-    {:ok, datetime}
-  end
-
-  @doc """
-  Converts the given `NaiveDateTime` to `DateTime`.
-
-  It expects a time zone to put the NaiveDateTime in.
-  Currently it only supports "Etc/UTC" as time zone.
-
-  ## Examples
-
-      iex> DateTime.from_naive!(~N[2016-05-24 13:26:08.003], "Etc/UTC")
-      #DateTime<2016-05-24 13:26:08.003Z>
-
-  """
-  @doc since: "1.4.0"
-  @spec from_naive!(NaiveDateTime.t(), Calendar.time_zone()) :: t
-  def from_naive!(naive_datetime, time_zone) do
-    case from_naive(naive_datetime, time_zone) do
-      {:ok, datetime} ->
-        datetime
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot parse #{inspect(naive_datetime)} to datetime, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given `datetime` to Unix time.
-
-  The `datetime` is expected to be using the ISO calendar
-  with a year greater than or equal to 0.
-
-  It will return the integer with the given unit,
-  according to `System.convert_time_unit/3`.
-
-  ## Examples
-
-      iex> 1_464_096_368 |> DateTime.from_unix!() |> DateTime.to_unix()
-      1464096368
-
-      iex> dt = %DateTime{calendar: Calendar.ISO, day: 20, hour: 18, microsecond: {273806, 6},
-      ...>                minute: 58, month: 11, second: 19, time_zone: "America/Montevideo",
-      ...>                utc_offset: -10800, std_offset: 3600, year: 2014, zone_abbr: "UYST"}
-      iex> DateTime.to_unix(dt)
-      1416517099
-
-      iex> flamel = %DateTime{calendar: Calendar.ISO, day: 22, hour: 8, microsecond: {527771, 6},
-      ...>                minute: 2, month: 3, second: 25, std_offset: 0, time_zone: "Etc/UTC",
-      ...>                utc_offset: 0, year: 1418, zone_abbr: "UTC"}
-      iex> DateTime.to_unix(flamel)
-      -17412508655
-
-  """
-  @spec to_unix(Calendar.datetime(), System.time_unit()) :: integer
-  def to_unix(datetime, unit \\ :second)
-
-  def to_unix(%{utc_offset: utc_offset, std_offset: std_offset} = datetime, unit) do
-    {days, fraction} = to_iso_days(datetime)
-    unix_units = Calendar.ISO.iso_days_to_unit({days - @unix_days, fraction}, unit)
-    offset_units = System.convert_time_unit(utc_offset + std_offset, :second, unit)
-    unix_units - offset_units
-  end
-
-  @doc """
-  Converts the given `datetime` into a `NaiveDateTime`.
-
-  Because `NaiveDateTime` does not hold time zone information,
-  any time zone related data will be lost during the conversion.
-
-  ## Examples
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.to_naive(dt)
-      ~N[2000-02-29 23:00:07.0]
-
-  """
-  @spec to_naive(t) :: NaiveDateTime.t()
-  def to_naive(%DateTime{} = datetime) do
-    %DateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = datetime
-
-    %NaiveDateTime{
-      year: year,
-      month: month,
-      day: day,
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-  end
-
-  @doc """
-  Converts a `DateTime` into a `Date`.
-
-  Because `Date` does not hold time nor time zone information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.to_date(dt)
-      ~D[2000-02-29]
-
-  """
-  @spec to_date(t) :: Date.t()
-  def to_date(%DateTime{} = datetime) do
-    %{year: year, month: month, day: day, calendar: calendar} = datetime
-    %Date{year: year, month: month, day: day, calendar: calendar}
-  end
-
-  @doc """
-  Converts a `DateTime` into `Time`.
-
-  Because `Time` does not hold date nor time zone information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 1},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.to_time(dt)
-      ~T[23:00:07.0]
-
-  """
-  @spec to_time(t) :: Time.t()
-  def to_time(%DateTime{} = datetime) do
-    %{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: calendar} =
-      datetime
-
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    }
-  end
-
-  @doc """
-  Converts the given datetime to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601) format.
-
-  By default, `DateTime.to_iso8601/2` returns datetimes formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
-
-  Only supports converting datetimes which are in the ISO calendar,
-  attempting to convert datetimes from other calendars will raise.
-
-  WARNING: the ISO 8601 datetime format does not contain the time zone nor
-  its abbreviation, which means information is lost when converting to such
-  format.
-
-  ### Examples
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.to_iso8601(dt)
-      "2000-02-29T23:00:07+01:00"
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
-      iex> DateTime.to_iso8601(dt)
-      "2000-02-29T23:00:07Z"
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> DateTime.to_iso8601(dt, :extended)
-      "2000-02-29T23:00:07-04:00"
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> DateTime.to_iso8601(dt, :basic)
-      "20000229T230007-0400"
-
-  """
-  @spec to_iso8601(Calendar.datetime(), :extended | :basic) :: String.t()
-  def to_iso8601(datetime, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = datetime, format)
-      when format in [:extended, :basic] do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      time_zone: time_zone,
-      zone_abbr: zone_abbr,
-      utc_offset: utc_offset,
-      std_offset: std_offset
-    } = datetime
-
-    Calendar.ISO.datetime_to_iso8601(
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      microsecond,
-      time_zone,
-      zone_abbr,
-      utc_offset,
-      std_offset,
-      format
-    )
-  end
-
-  def to_iso8601(%{calendar: _} = datetime, format) when format in [:extended, :basic] do
-    datetime
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  @doc """
-  Parses the extended "Date and time of day" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Since ISO 8601 does not include the proper time zone, the given
-  string will be converted to UTC and its offset in seconds will be
-  returned as part of this function. Therefore offset information
-  must be present in the string.
-
-  As specified in the standard, the separator "T" may be omitted if
-  desired as there is no ambiguity within this function.
-
-  Time representations with reduced accuracy are not supported.
-
-  Note that while ISO 8601 allows datetimes to specify 24:00:00 as the
-  zero hour of the next day, this notation is not supported by Elixir.
-
-  ## Examples
-
-      iex> {:ok, datetime, 0} = DateTime.from_iso8601("2015-01-23T23:50:07Z")
-      iex> datetime
-      #DateTime<2015-01-23 23:50:07Z>
-
-      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
-      iex> datetime
-      #DateTime<2015-01-23 21:20:07.123Z>
-
-      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("2015-01-23T23:50:07,123+02:30")
-      iex> datetime
-      #DateTime<2015-01-23 21:20:07.123Z>
-
-      iex> {:ok, datetime, 0} = DateTime.from_iso8601("-2015-01-23T23:50:07Z")
-      iex> datetime
-      #DateTime<-2015-01-23 23:50:07Z>
-
-      iex> {:ok, datetime, 9000} = DateTime.from_iso8601("-2015-01-23T23:50:07,123+02:30")
-      iex> datetime
-      #DateTime<-2015-01-23 21:20:07.123Z>
-
-      iex> DateTime.from_iso8601("2015-01-23P23:50:07")
-      {:error, :invalid_format}
-      iex> DateTime.from_iso8601("2015-01-23 23:50:07A")
-      {:error, :invalid_format}
-      iex> DateTime.from_iso8601("2015-01-23T23:50:07")
-      {:error, :missing_offset}
-      iex> DateTime.from_iso8601("2015-01-23 23:50:61")
-      {:error, :invalid_time}
-      iex> DateTime.from_iso8601("2015-01-32 23:50:07")
-      {:error, :invalid_date}
-
-      iex> DateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
-      {:error, :invalid_format}
-      iex> DateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
-      {:error, :invalid_format}
-
-  """
-  @doc since: "1.4.0"
-  @spec from_iso8601(String.t(), Calendar.calendar()) ::
-          {:ok, t, Calendar.utc_offset()} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<?-, rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar, true)
-  end
-
-  def from_iso8601(<<rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar, false)
-  end
-
-  @sep [?\s, ?T]
-  [match_date, guard_date, read_date] = Calendar.ISO.__match_date__()
-  [match_time, guard_time, read_time] = Calendar.ISO.__match_time__()
-
-  defp raw_from_iso8601(string, calendar, is_negative_datetime) do
-    with <<unquote(match_date), sep, unquote(match_time), rest::binary>> <- string,
-         true <- unquote(guard_date) and sep in @sep and unquote(guard_time),
-         {microsecond, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {offset, ""} <- Calendar.ISO.parse_offset(rest) do
-      {year, month, day} = unquote(read_date)
-      {hour, minute, second} = unquote(read_time)
-      year = if is_negative_datetime, do: -year, else: year
-
-      cond do
-        not calendar.valid_date?(year, month, day) ->
-          {:error, :invalid_date}
-
-        not calendar.valid_time?(hour, minute, second, microsecond) ->
-          {:error, :invalid_time}
-
-        offset == 0 ->
-          datetime = %DateTime{
-            calendar: calendar,
-            year: year,
-            month: month,
-            day: day,
-            hour: hour,
-            minute: minute,
-            second: second,
-            microsecond: microsecond,
-            std_offset: 0,
-            utc_offset: 0,
-            zone_abbr: "UTC",
-            time_zone: "Etc/UTC"
-          }
-
-          {:ok, datetime, 0}
-
-        is_nil(offset) ->
-          {:error, :missing_offset}
-
-        true ->
-          {_, precision} = microsecond
-
-          datetime =
-            Calendar.ISO.naive_datetime_to_iso_days(
-              year,
-              month,
-              day,
-              hour,
-              minute,
-              second,
-              microsecond
-            )
-            |> apply_tz_offset(offset)
-            |> from_iso_days("Etc/UTC", "UTC", 0, 0, calendar, precision)
-
-          {:ok, %{datetime | microsecond: microsecond}, offset}
-      end
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  @doc """
-  Converts the given `datetime` to a string according to its calendar.
-
-  ### Examples
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.to_string(dt)
-      "2000-02-29 23:00:07+01:00 CET Europe/Warsaw"
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "UTC",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 0, std_offset: 0, time_zone: "Etc/UTC"}
-      iex> DateTime.to_string(dt)
-      "2000-02-29 23:00:07Z"
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> DateTime.to_string(dt)
-      "2000-02-29 23:00:07-04:00 AMT America/Manaus"
-
-      iex> dt = %DateTime{year: -100, month: 12, day: 19, zone_abbr: "CET",
-      ...>                hour: 3, minute: 20, second: 31, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Stockholm"}
-      iex> DateTime.to_string(dt)
-      "-0100-12-19 03:20:31+01:00 CET Europe/Stockholm"
-
-  """
-  @spec to_string(Calendar.datetime()) :: String.t()
-  def to_string(%{calendar: calendar} = datetime) do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      time_zone: time_zone,
-      zone_abbr: zone_abbr,
-      utc_offset: utc_offset,
-      std_offset: std_offset
-    } = datetime
-
-    calendar.datetime_to_string(
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      microsecond,
-      time_zone,
-      zone_abbr,
-      utc_offset,
-      std_offset
-    )
-  end
-
-  @doc """
-  Compares two datetime structs.
-
-  Returns `:gt` if the first datetime is later than the second
-  and `:lt` for vice versa. If the two datetimes are equal
-  `:eq` is returned.
-
-  Note that both UTC and Standard offsets will be taken into
-  account when comparison is done.
-
-  ## Examples
-
-      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.compare(dt1, dt2)
-      :gt
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.datetime(), Calendar.datetime()) :: :lt | :eq | :gt
-  def compare(
-        %{calendar: _, utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,
-        %{calendar: _, utc_offset: utc_offset2, std_offset: std_offset2} = datetime2
-      ) do
-    {days1, {parts1, ppd1}} =
-      datetime1
-      |> to_iso_days()
-      |> apply_tz_offset(utc_offset1 + std_offset1)
-
-    {days2, {parts2, ppd2}} =
-      datetime2
-      |> to_iso_days()
-      |> apply_tz_offset(utc_offset2 + std_offset2)
-
-    # Ensure fraction tuples have same denominator.
-    iso_days1 = {days1, parts1 * ppd2}
-    iso_days2 = {days2, parts2 * ppd1}
-
-    case {iso_days1, iso_days2} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  @doc """
-  Subtracts `datetime2` from `datetime1`.
-
-  The answer can be returned in any `unit` available from `t:System.time_unit/0`.
-
-  Leap seconds are not taken into account.
-
-  This function returns the difference in seconds where seconds are measured
-  according to `Calendar.ISO`.
-
-  ## Examples
-
-      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> dt2 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> DateTime.diff(dt1, dt2)
-      18000
-      iex> DateTime.diff(dt2, dt1)
-      -18000
-
-  """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.datetime(), Calendar.datetime()) :: integer()
-  def diff(
-        %{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,
-        %{utc_offset: utc_offset2, std_offset: std_offset2} = datetime2,
-        unit \\ :second
-      ) do
-    naive_diff =
-      (datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)) -
-        (datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit))
-
-    offset_diff = utc_offset2 + std_offset2 - (utc_offset1 + std_offset1)
-    naive_diff + System.convert_time_unit(offset_diff, :second, unit)
-  end
-
-  @doc """
-  Returns the given datetime with the microsecond field truncated to the given
-  precision (`:microsecond`, `millisecond` or `:second`).
-
-  ## Examples
-
-      iex> dt1 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
-      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
-      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
-      iex> DateTime.truncate(dt1, :microsecond)
-      #DateTime<2017-11-07 11:45:18.123456+01:00 CET Europe/Paris>
-
-      iex> dt2 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
-      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
-      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
-      iex> DateTime.truncate(dt2, :millisecond)
-      #DateTime<2017-11-07 11:45:18.123+01:00 CET Europe/Paris>
-
-      iex> dt3 = %DateTime{year: 2017, month: 11, day: 7, zone_abbr: "CET",
-      ...>                 hour: 11, minute: 45, second: 18, microsecond: {123456, 6},
-      ...>                 utc_offset: 3600, std_offset: 0, time_zone: "Europe/Paris"}
-      iex> DateTime.truncate(dt3, :second)
-      #DateTime<2017-11-07 11:45:18+01:00 CET Europe/Paris>
-
-  """
-  @doc since: "1.6.0"
-  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
-  def truncate(%DateTime{microsecond: microsecond} = datetime, precision) do
-    %{datetime | microsecond: Calendar.truncate(microsecond, precision)}
-  end
-
-  @doc """
-  Converts a given `datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple
-  is returned.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> DateTime.convert(dt1, Calendar.Holocene)
-      {:ok, %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
-                      microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
-                      time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
-                      zone_abbr: "AMT"}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.datetime(), Calendar.calendar()) ::
-          {:ok, t} | {:error, :incompatible_calendars}
-
-  # Keep it multiline for proper function clause errors.
-  def convert(
-        %{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond,
-          time_zone: time_zone,
-          zone_abbr: zone_abbr,
-          utc_offset: utc_offset,
-          std_offset: std_offset
-        },
-        calendar
-      ) do
-    datetime = %DateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      time_zone: time_zone,
-      zone_abbr: zone_abbr,
-      utc_offset: utc_offset,
-      std_offset: std_offset
-    }
-
-    {:ok, datetime}
-  end
-
-  def convert(%{calendar: dt_calendar, microsecond: {_, precision}} = datetime, calendar) do
-    if Calendar.compatible_calendars?(dt_calendar, calendar) do
-      result_datetime =
-        datetime
-        |> to_iso_days
-        |> from_iso_days(datetime, calendar, precision)
-
-      {:ok, result_datetime}
-    else
-      {:error, :incompatible_calendars}
-    end
-  end
-
-  @doc """
-  Converts a given `datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> dt1 = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "AMT",
-      ...>                 hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                 utc_offset: -14400, std_offset: 0, time_zone: "America/Manaus"}
-      iex> DateTime.convert!(dt1, Calendar.Holocene)
-      %DateTime{calendar: Calendar.Holocene, day: 29, hour: 23,
-                microsecond: {0, 0}, minute: 0, month: 2, second: 7, std_offset: 0,
-                time_zone: "America/Manaus", utc_offset: -14400, year: 12000,
-                zone_abbr: "AMT"}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.datetime(), Calendar.calendar()) :: t | no_return
-  def convert!(datetime, calendar) do
-    case convert(datetime, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, :incompatible_calendars} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(datetime)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(datetime.calendar)} and #{inspect(calendar)} have different " <>
-                "day rollover moments, making this conversion ambiguous"
-    end
-  end
-
-  # Keep it multiline for proper function clause errors.
-  defp to_iso_days(%{
-         calendar: calendar,
-         year: year,
-         month: month,
-         day: day,
-         hour: hour,
-         minute: minute,
-         second: second,
-         microsecond: microsecond
-       }) do
-    calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
-  end
-
-  defp from_iso_days(iso_days, datetime, calendar, precision) do
-    %{time_zone: time_zone, zone_abbr: zone_abbr, utc_offset: utc_offset, std_offset: std_offset} =
-      datetime
-
-    from_iso_days(iso_days, time_zone, zone_abbr, utc_offset, std_offset, calendar, precision)
-  end
-
-  defp from_iso_days(iso_days, time_zone, zone_abbr, utc_offset, std_offset, calendar, precision) do
-    {year, month, day, hour, minute, second, {microsecond, _}} =
-      calendar.naive_datetime_from_iso_days(iso_days)
-
-    %DateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision},
-      time_zone: time_zone,
-      zone_abbr: zone_abbr,
-      utc_offset: utc_offset,
-      std_offset: std_offset
-    }
-  end
-
-  defp apply_tz_offset(iso_days, offset) do
-    Calendar.ISO.add_day_fraction_to_iso_days(iso_days, -offset, 86400)
-  end
-
-  defimpl String.Chars do
-    def to_string(datetime) do
-      %{
-        calendar: calendar,
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        time_zone: time_zone,
-        zone_abbr: zone_abbr,
-        utc_offset: utc_offset,
-        std_offset: std_offset
-      } = datetime
-
-      calendar.datetime_to_string(
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second,
-        microsecond,
-        time_zone,
-        zone_abbr,
-        utc_offset,
-        std_offset
-      )
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: Calendar.ISO} = datetime, _) do
-      %{
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        time_zone: time_zone,
-        zone_abbr: zone_abbr,
-        utc_offset: utc_offset,
-        std_offset: std_offset
-      } = datetime
-
-      "#DateTime<" <>
-        Calendar.ISO.datetime_to_string(
-          year,
-          month,
-          day,
-          hour,
-          minute,
-          second,
-          microsecond,
-          time_zone,
-          zone_abbr,
-          utc_offset,
-          std_offset
-        ) <> ">"
-    end
-
-    def inspect(datetime, opts) do
-      Inspect.Any.inspect(datetime, opts)
-    end
-  end
-end

lib/elixir/lib/calendar/iso.ex

@@ -1,279 +1,42 @@
 defmodule Calendar.ISO do
   @moduledoc """
-  A calendar implementation that follows to ISO 8601.
+  A calendar implementation that follows to ISO8601.
 
   This calendar implements the proleptic Gregorian calendar and
   is therefore compatible with the calendar used in most countries
   today. The proleptic means the Gregorian rules for leap years are
   applied for all time, consequently the dates give different results
   before the year 1583 from when the Gregorian calendar was adopted.
-
-  Note that while ISO 8601 allows times and datetimes to specify
-  24:00:00 as the zero hour of the next day, this notation is not
-  supported by Elixir.
   """
 
   @behaviour Calendar
 
-  @unix_epoch 62_167_219_200
-  unix_start = (315_537_897_600 + @unix_epoch) * -1_000_000
-  unix_end = 315_569_519_999_999_999 - @unix_epoch * 1_000_000
-  @unix_range_microseconds unix_start..unix_end
-
-  @type year :: -9999..9999
-  @type month :: 1..12
-  @type day :: 1..31
-
-  @seconds_per_minute 60
-  @seconds_per_hour 60 * 60
-  # Note that this does _not_ handle leap seconds.
-  @seconds_per_day 24 * 60 * 60
-  @last_second_of_the_day @seconds_per_day - 1
-  @microseconds_per_second 1_000_000
-  @parts_per_day @seconds_per_day * @microseconds_per_second
-
-  @days_per_nonleap_year 365
-  @days_per_leap_year 366
-
-  @months_in_year 12
-
-  @doc false
-  def __match_date__ do
-    quote do
-      [
-        <<y1, y2, y3, y4, ?-, m1, m2, ?-, d1, d2>>,
-        y1 >= ?0 and y1 <= ?9 and y2 >= ?0 and y2 <= ?9 and y3 >= ?0 and y3 <= ?9 and y4 >= ?0 and
-          y4 <= ?9 and m1 >= ?0 and m1 <= ?9 and m2 >= ?0 and m2 <= ?9 and d1 >= ?0 and d1 <= ?9 and
-          d2 >= ?0 and d2 <= ?9,
-        {
-          (y1 - ?0) * 1000 + (y2 - ?0) * 100 + (y3 - ?0) * 10 + (y4 - ?0),
-          (m1 - ?0) * 10 + (m2 - ?0),
-          (d1 - ?0) * 10 + (d2 - ?0)
-        }
-      ]
-    end
-  end
-
-  @doc false
-  def __match_time__ do
-    quote do
-      [
-        <<h1, h2, ?:, i1, i2, ?:, s1, s2>>,
-        h1 >= ?0 and h1 <= ?9 and h2 >= ?0 and h2 <= ?9 and i1 >= ?0 and i1 <= ?9 and i2 >= ?0 and
-          i2 <= ?9 and s1 >= ?0 and s1 <= ?9 and s2 >= ?0 and s2 <= ?9,
-        {
-          (h1 - ?0) * 10 + (h2 - ?0),
-          (i1 - ?0) * 10 + (i2 - ?0),
-          (s1 - ?0) * 10 + (s2 - ?0)
-        }
-      ]
-    end
-  end
-
   @doc """
-  Returns the `t:Calendar.iso_days/0` format of the specified date.
+  Builds and validates an ISO date.
 
   ## Examples
 
-      iex> Calendar.ISO.naive_datetime_to_iso_days(0, 1, 1, 0, 0, 0, {0, 6})
-      {0, {0, 86400000000}}
-      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 12, 0, 0, {0, 6})
-      {730485, {43200000000, 86400000000}}
-      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 13, 0, 0, {0, 6})
-      {730485, {46800000000, 86400000000}}
-      iex> Calendar.ISO.naive_datetime_to_iso_days(-1, 1, 1, 0, 0, 0, {0, 6})
-      {-365, {0, 86400000000}}
+      iex> Calendar.ISO.date(2000, 1, 1)
+      {:ok, ~D[2000-01-01]}
+      iex> Calendar.ISO.date(2000, 13, 1)
+      {:error, :invalid_date}
+      iex> Calendar.ISO.date(2000, 2, 29)
+      {:ok, ~D[2000-02-29]}
+
+      iex> Calendar.ISO.date(2000, 2, 30)
+      {:error, :invalid_date}
+      iex> Calendar.ISO.date(2001, 2, 29)
+      {:error, :invalid_date}
 
   """
-  @doc since: "1.5.0"
-  @impl true
-  @spec naive_datetime_to_iso_days(
-          Calendar.year(),
-          Calendar.month(),
-          Calendar.day(),
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond()
-        ) :: Calendar.iso_days()
-  def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do
-    {date_to_iso_days(year, month, day), time_to_day_fraction(hour, minute, second, microsecond)}
-  end
-
-  @doc """
-  Converts the `t:Calendar.iso_days/0` format to the datetime format specified by this calendar.
-
-  ## Examples
-
-      iex> Calendar.ISO.naive_datetime_from_iso_days({0, {0, 86400}})
-      {0, 1, 1, 0, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {0, 86400}})
-      {2000, 1, 1, 0, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({730_485, {43200, 86400}})
-      {2000, 1, 1, 12, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({-365, {0, 86400000000}})
-      {-1, 1, 1, 0, 0, 0, {0, 6}}
-
-  """
-  @doc since: "1.5.0"
-  @spec naive_datetime_from_iso_days(Calendar.iso_days()) :: {
-          Calendar.year(),
-          Calendar.month(),
-          Calendar.day(),
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond()
-        }
-  @impl true
-  def naive_datetime_from_iso_days({days, day_fraction}) do
-    {year, month, day} = date_from_iso_days(days)
-    {hour, minute, second, microsecond} = time_from_day_fraction(day_fraction)
-    {year, month, day, hour, minute, second, microsecond}
-  end
-
-  @doc """
-  Returns the normalized day fraction of the specified time.
-
-  ## Examples
-
-      iex> Calendar.ISO.time_to_day_fraction(0, 0, 0, {0, 6})
-      {0, 86400000000}
-      iex> Calendar.ISO.time_to_day_fraction(12, 34, 56, {123, 6})
-      {45296000123, 86400000000}
-
-  """
-  @doc since: "1.5.0"
-  @impl true
-  @spec time_to_day_fraction(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond()
-        ) :: Calendar.day_fraction()
-  def time_to_day_fraction(0, 0, 0, {0, _}) do
-    {0, @parts_per_day}
-  end
-
-  def time_to_day_fraction(hour, minute, second, {microsecond, _}) do
-    combined_seconds = hour * @seconds_per_hour + minute * @seconds_per_minute + second
-    {combined_seconds * @microseconds_per_second + microsecond, @parts_per_day}
-  end
-
-  @doc """
-  Converts a day fraction to this Calendar's representation of time.
-
-  ## Examples
-
-      iex> Calendar.ISO.time_from_day_fraction({1, 2})
-      {12, 0, 0, {0, 6}}
-      iex> Calendar.ISO.time_from_day_fraction({13, 24})
-      {13, 0, 0, {0, 6}}
-
-  """
-  @doc since: "1.5.0"
-  @impl true
-  @spec time_from_day_fraction(Calendar.day_fraction()) ::
-          {Calendar.hour(), Calendar.minute(), Calendar.second(), Calendar.microsecond()}
-  def time_from_day_fraction({parts_in_day, parts_per_day}) do
-    total_microseconds = div(parts_in_day * @parts_per_day, parts_per_day)
-
-    {hours, rest_microseconds1} =
-      div_mod(total_microseconds, @seconds_per_hour * @microseconds_per_second)
-
-    {minutes, rest_microseconds2} =
-      div_mod(rest_microseconds1, @seconds_per_minute * @microseconds_per_second)
-
-    {seconds, microseconds} = div_mod(rest_microseconds2, @microseconds_per_second)
-    {hours, minutes, seconds, {microseconds, 6}}
-  end
-
-  # Converts year, month, day to count of days since 0000-01-01.
-  @doc false
-  @doc since: "1.5.0"
-  def date_to_iso_days(0, 1, 1) do
-    0
-  end
-
-  def date_to_iso_days(1970, 1, 1) do
-    719_528
-  end
-
-  def date_to_iso_days(year, month, day) when year in -9999..9999 do
-    true = day <= days_in_month(year, month)
-
-    days_in_previous_years(year) + days_before_month(month) + leap_day_offset(year, month) + day -
-      1
-  end
-
-  # Converts count of days since 0000-01-01 to {year, month, day} tuple.
-  @doc false
-  def date_from_iso_days(days) when days in -3_652_059..3_652_424 do
-    {year, day_of_year} = days_to_year(days)
-    extra_day = if leap_year?(year), do: 1, else: 0
-    {month, day_in_month} = year_day_to_year_date(extra_day, day_of_year)
-    {year, month, day_in_month + 1}
-  end
-
-  defp div_mod(int1, int2) do
-    div = div(int1, int2)
-    rem = int1 - div * int2
-
-    if rem >= 0 do
-      {div, rem}
+  def date(year, month, day) when is_integer(year) and is_integer(month) and is_integer(day) do
+    if :calendar.valid_date(year, month, day) and year <= 9999 do
+      {:ok, %Date{year: year, month: month, day: day}}
     else
-      {div - 1, rem + int2}
+      {:error, :invalid_date}
     end
   end
 
-  @doc """
-  Returns how many days there are in the given year-month.
-
-  ## Examples
-
-      iex> Calendar.ISO.days_in_month(1900, 1)
-      31
-      iex> Calendar.ISO.days_in_month(1900, 2)
-      28
-      iex> Calendar.ISO.days_in_month(2000, 2)
-      29
-      iex> Calendar.ISO.days_in_month(2001, 2)
-      28
-      iex> Calendar.ISO.days_in_month(2004, 2)
-      29
-      iex> Calendar.ISO.days_in_month(2004, 4)
-      30
-      iex> Calendar.ISO.days_in_month(-1, 5)
-      31
-
-  """
-  @spec days_in_month(year, month) :: 28..31
-  @impl true
-  def days_in_month(year, month)
-
-  def days_in_month(year, 2) do
-    if leap_year?(year), do: 29, else: 28
-  end
-
-  def days_in_month(_, month) when month in [4, 6, 9, 11], do: 30
-  def days_in_month(_, month) when month in 1..12, do: 31
-
-  @doc """
-  Returns how many months there are in the given year.
-
-  ## Example
-
-      iex> Calendar.ISO.months_in_year(2004)
-      12
-
-  """
-  @doc since: "1.7.0"
-  @impl true
-  @spec months_in_year(year) :: 12
-  def months_in_year(_year) do
-    @months_in_year
-  end
-
   @doc """
   Returns if the given year is a leap year.
 
@@ -287,354 +50,97 @@ defmodule Calendar.ISO do
       true
       iex> Calendar.ISO.leap_year?(1900)
       false
-      iex> Calendar.ISO.leap_year?(-4)
-      true
 
   """
-  @spec leap_year?(year) :: boolean()
-  @impl true
-  def leap_year?(year) when is_integer(year) do
-    rem(year, 4) === 0 and (rem(year, 100) !== 0 or rem(year, 400) === 0)
+  def leap_year?(year) when is_integer(year) and year >= 0 do
+    rem(year, 4) === 0 and (rem(year, 100) > 0 or rem(year, 400) === 0)
   end
 
   @doc """
-  Calculates the day of the week from the given `year`, `month`, and `day`.
-
-  It is an integer from 1 to 7, where 1 is Monday and 7 is Sunday.
-
-  ## Examples
-
-      iex> Calendar.ISO.day_of_week(2016, 10, 31)
-      1
-      iex> Calendar.ISO.day_of_week(2016, 11, 1)
-      2
-      iex> Calendar.ISO.day_of_week(2016, 11, 2)
-      3
-      iex> Calendar.ISO.day_of_week(2016, 11, 3)
-      4
-      iex> Calendar.ISO.day_of_week(2016, 11, 4)
-      5
-      iex> Calendar.ISO.day_of_week(2016, 11, 5)
-      6
-      iex> Calendar.ISO.day_of_week(2016, 11, 6)
-      7
-      iex> Calendar.ISO.day_of_week(-99, 1, 31)
-      4
+  Converts the given structure into a string.
 
+  It uses the ISO8601 standard except for DateTime where the
+  timezone information is added between brackets.
   """
-  @spec day_of_week(year, month, day) :: 1..7
-  @impl true
-  def day_of_week(year, month, day)
-      when is_integer(year) and is_integer(month) and is_integer(day) do
-    Integer.mod(date_to_iso_days(year, month, day) + 5, 7) + 1
+  def to_string(%Date{year: year, month: month, day: day}) do
+    date_to_string(year, month, day)
   end
 
-  @doc """
-  Converts the given time into a string.
-
-  ## Examples
-
-      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 6})
-      "02:02:02.000002"
-      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 2})
-      "02:02:02.00"
-      iex> Calendar.ISO.time_to_string(2, 2, 2, {2, 0})
-      "02:02:02"
-
-  """
-  @spec time_to_string(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond()
-        ) :: String.t()
-  @impl true
-  def time_to_string(hour, minute, second, microsecond) do
-    time_to_string(hour, minute, second, microsecond, :extended)
+  def to_string(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
+    time_to_string(hour, minute, second, microsecond)
   end
 
-  def time_to_string(hour, minute, second, {_, 0}, format) do
-    time_to_string_format(hour, minute, second, format)
-  end
-
-  def time_to_string(hour, minute, second, {microsecond, precision}, format) do
-    time_to_string_format(hour, minute, second, format) <>
-      "." <> (microsecond |> zero_pad(6) |> binary_part(0, precision))
-  end
-
-  defp time_to_string_format(hour, minute, second, :extended) do
-    zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2) <> ":" <> zero_pad(second, 2)
-  end
-
-  defp time_to_string_format(hour, minute, second, :basic) do
-    zero_pad(hour, 2) <> zero_pad(minute, 2) <> zero_pad(second, 2)
-  end
-
-  @doc """
-  Converts the given date into a string.
-
-  ## Examples
-
-      iex> Calendar.ISO.date_to_string(2015, 2, 28)
-      "2015-02-28"
-      iex> Calendar.ISO.date_to_string(2017, 8, 1)
-      "2017-08-01"
-      iex> Calendar.ISO.date_to_string(-99, 1, 31)
-      "-0099-01-31"
-
-  """
-  @spec date_to_string(year, month, day) :: String.t()
-  @impl true
-  def date_to_string(year, month, day) do
-    date_to_string(year, month, day, :extended)
-  end
-
-  defp date_to_string(year, month, day, :extended) do
-    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
-  end
-
-  defp date_to_string(year, month, day, :basic) do
-    zero_pad(year, 4) <> zero_pad(month, 2) <> zero_pad(day, 2)
-  end
-
-  @doc """
-  Converts the datetime (without time zone) into a string.
-
-  ## Examples
-
-      iex> Calendar.ISO.naive_datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 6})
-      "2015-02-28 01:02:03.000004"
-      iex> Calendar.ISO.naive_datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5})
-      "2017-08-01 01:02:03.00000"
-
-  """
-  @impl true
-  @spec naive_datetime_to_string(
-          year,
-          month,
-          day,
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond()
-        ) :: String.t()
-  def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do
+  def to_string(%NaiveDateTime{year: year, month: month, day: day,
+                               hour: hour, minute: minute, second: second, microsecond: microsecond}) do
     date_to_string(year, month, day) <> " " <> time_to_string(hour, minute, second, microsecond)
   end
 
-  @doc """
-  Converts the datetime (with time zone) into a string.
-
-  ## Examples
-
-      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, "Europe/Berlin", "CET", 3600, 0)
-      "2017-08-01 01:02:03.00000+01:00 CET Europe/Berlin"
-      iex> Calendar.ISO.datetime_to_string(2017, 8, 1, 1, 2, 3, {4, 5}, "Europe/Berlin", "CDT", 3600, 3600)
-      "2017-08-01 01:02:03.00000+02:00 CDT Europe/Berlin"
-      iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, "America/Los_Angeles", "PST", -28800, 0)
-      "2015-02-28 01:02:03.00000-08:00 PST America/Los_Angeles"
-      iex> Calendar.ISO.datetime_to_string(2015, 2, 28, 1, 2, 3, {4, 5}, "America/Los_Angeles", "PDT", -28800, 3600)
-      "2015-02-28 01:02:03.00000-07:00 PDT America/Los_Angeles"
-
-  """
-  @impl true
-  @spec datetime_to_string(
-          year,
-          month,
-          day,
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond(),
-          Calendar.time_zone(),
-          Calendar.zone_abbr(),
-          Calendar.utc_offset(),
-          Calendar.std_offset()
-        ) :: String.t()
-  def datetime_to_string(
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second,
-        microsecond,
-        time_zone,
-        zone_abbr,
-        utc_offset,
-        std_offset
-      ) do
-    date_to_string(year, month, day) <>
-      " " <>
+  def to_string(%DateTime{year: year, month: month, day: day, zone_abbr: zone_abbr,
+                          hour: hour, minute: minute, second: second, microsecond: microsecond,
+                          utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
+    date_to_string(year, month, day) <> " " <>
       time_to_string(hour, minute, second, microsecond) <>
       offset_to_string(utc_offset, std_offset, time_zone) <>
       zone_to_string(utc_offset, std_offset, zone_abbr, time_zone)
   end
 
-  @doc """
-  Determines if the date given is valid according to the proleptic Gregorian calendar.
-
-  ## Examples
-
-      iex> Calendar.ISO.valid_date?(2015, 2, 28)
-      true
-      iex> Calendar.ISO.valid_date?(2015, 2, 30)
-      false
-      iex> Calendar.ISO.valid_date?(-1, 12, 31)
-      true
-      iex> Calendar.ISO.valid_date?(-1, 12, 32)
-      false
-
-  """
-  @doc since: "1.5.0"
-  @impl true
-  @spec valid_date?(year, month, day) :: boolean
-  def valid_date?(year, month, day) do
-    month in 1..12 and year in -9999..9999 and
-      (is_integer(day) and day >= 1 and day <= days_in_month(year, month))
+  defp date_to_string(year, month, day) do
+    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
   end
 
-  @doc """
-  Determines if the date given is valid according to the proleptic Gregorian calendar.
-  Note that leap seconds are considered valid, but the use of 24:00:00 as the
-  zero hour of the day is considered invalid.
-
-  ## Examples
-
-      iex> Calendar.ISO.valid_time?(10, 50, 25, {3006, 6})
-      true
-      iex> Calendar.ISO.valid_time?(23, 59, 60, {0, 0})
-      true
-      iex> Calendar.ISO.valid_time?(24, 0, 0, {0, 0})
-      false
-
-  """
-  @doc since: "1.5.0"
-  @impl true
-  @spec valid_time?(Calendar.hour(), Calendar.minute(), Calendar.secon(), Calendar.microsecond()) ::
-          boolean
-  def valid_time?(hour, minute, second, {microsecond, precision}) do
-    hour in 0..23 and minute in 0..59 and second in 0..60 and microsecond in 0..999_999 and
-      precision in 0..6
+  defp time_to_string(hour, minute, second, 0) do
+    zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2) <> ":" <> zero_pad(second, 2)
+  end
+  defp time_to_string(hour, minute, second, {_, 0}) do
+    time_to_string(hour, minute, second, 0)
+  end
+  defp time_to_string(hour, minute, second, {microsecond, precision}) do
+    time_to_string(hour, minute, second, 0) <> "." <>
+      (microsecond |> zero_pad(6) |> binary_part(0, precision))
   end
 
-  @doc """
-  See `c:Calendar.day_rollover_relative_to_midlight_utc/0` for documentation.
-  """
-  @doc since: "1.5.0"
-  @impl true
-  @spec day_rollover_relative_to_midnight_utc() :: {0, 1}
-  def day_rollover_relative_to_midnight_utc() do
-    {0, 1}
-  end
-
-  defp offset_to_string(utc, std, zone, format \\ :extended)
-  defp offset_to_string(0, 0, "Etc/UTC", _format), do: "Z"
-
-  defp offset_to_string(utc, std, _zone, format) do
-    total = utc + std
+  defp offset_to_string(0, 0, "Etc/UTC"), do: "Z"
+  defp offset_to_string(utc, std, _zone) do
+    total  = utc + std
     second = abs(total)
     minute = second |> rem(3600) |> div(60)
-    hour = div(second, 3600)
-    format_offset(total, hour, minute, format)
-  end
-
-  defp format_offset(total, hour, minute, :extended) do
+    hour   = second |> div(3600)
     sign(total) <> zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2)
   end
 
-  defp format_offset(total, hour, minute, :basic) do
-    sign(total) <> zero_pad(hour, 2) <> zero_pad(minute, 2)
-  end
-
   defp zone_to_string(0, 0, _abbr, "Etc/UTC"), do: ""
   defp zone_to_string(_, _, abbr, zone), do: " " <> abbr <> " " <> zone
 
   defp sign(total) when total < 0, do: "-"
   defp sign(_), do: "+"
 
-  defp zero_pad(val, count) when val >= 0 do
+  defp zero_pad(val, count) do
     num = Integer.to_string(val)
     :binary.copy("0", count - byte_size(num)) <> num
   end
 
-  defp zero_pad(val, count) do
-    "-" <> zero_pad(-val, count)
-  end
-
   ## Helpers
 
   @doc false
-  def from_unix(integer, unit) when is_integer(integer) do
-    total = System.convert_time_unit(integer, unit, :microsecond)
-
-    if total in @unix_range_microseconds do
-      microseconds = Integer.mod(total, @microseconds_per_second)
-      seconds = @unix_epoch + Integer.floor_div(total, @microseconds_per_second)
-      precision = precision_for_unit(unit)
-      {date, time} = iso_seconds_to_datetime(seconds)
-      {:ok, date, time, {microseconds, precision}}
-    else
-      {:error, :invalid_unix_time}
-    end
+  def to_iso8601(%Date{year: year, month: month, day: day}) do
+    date_to_string(year, month, day)
   end
 
-  defp precision_for_unit(unit) do
-    subsecond = div(System.convert_time_unit(1, :second, unit), 10)
-    precision_for_unit(subsecond, 0)
+  def to_iso8601(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
+    time_to_string(hour, minute, second, microsecond)
   end
 
-  defp precision_for_unit(0, precision), do: precision
-  defp precision_for_unit(_, 6), do: 6
-
-  defp precision_for_unit(number, precision),
-    do: precision_for_unit(div(number, 10), precision + 1)
-
-  @doc false
-  @doc since: "1.5.0"
-  def date_to_iso8601(year, month, day, format \\ :extended) do
-    date_to_string(year, month, day, format)
+  def to_iso8601(%NaiveDateTime{year: year, month: month, day: day,
+                                hour: hour, minute: minute, second: second, microsecond: microsecond}) do
+    date_to_string(year, month, day) <> "T" <> time_to_string(hour, minute, second, microsecond)
   end
 
-  @doc false
-  def time_to_iso8601(hour, minute, second, microsecond, format \\ :extended) do
-    time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  @doc false
-  def naive_datetime_to_iso8601(
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second,
-        microsecond,
-        format \\ :extended
-      ) do
-    date_to_string(year, month, day, format) <>
-      "T" <> time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  @doc false
-  def datetime_to_iso8601(
-        year,
-        month,
-        day,
-        hour,
-        minute,
-        second,
-        microsecond,
-        time_zone,
-        _zone_abbr,
-        utc_offset,
-        std_offset,
-        format \\ :extended
-      ) do
-    date_to_string(year, month, day, format) <>
-      "T" <>
-      time_to_string(hour, minute, second, microsecond, format) <>
-      offset_to_string(utc_offset, std_offset, time_zone, format)
+  def to_iso8601(%DateTime{year: year, month: month, day: day,
+                           hour: hour, minute: minute, second: second, microsecond: microsecond,
+                           utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
+    date_to_string(year, month, day) <> "T" <>
+      time_to_string(hour, minute, second, microsecond) <>
+      offset_to_string(utc_offset, std_offset, time_zone)
   end
 
   @doc false
@@ -642,224 +148,42 @@ defmodule Calendar.ISO do
     case parse_microsecond(rest, 0, "") do
       {"", 0, _} ->
         :error
-
       {microsecond, precision, rest} when precision in 1..6 ->
         pad = String.duplicate("0", 6 - byte_size(microsecond))
         {{String.to_integer(microsecond <> pad), precision}, rest}
-
       {microsecond, _precision, rest} ->
         {{String.to_integer(binary_part(microsecond, 0, 6)), 6}, rest}
     end
   end
-
-  def parse_microsecond("," <> rest) do
-    parse_microsecond("." <> rest)
-  end
-
   def parse_microsecond(rest) do
     {{0, 0}, rest}
   end
 
-  defp parse_microsecond(<<head, tail::binary>>, precision, acc) when head in ?0..?9,
-    do: parse_microsecond(tail, precision + 1, <<acc::binary, head>>)
-
-  defp parse_microsecond(rest, precision, acc), do: {acc, precision, rest}
+  defp parse_microsecond(<<h, t::binary>>, precision, acc) when h in ?0..?9,
+    do: parse_microsecond(t, precision + 1, <<acc::binary, h>>)
+  defp parse_microsecond(rest, precision, acc),
+    do: {acc, precision, rest}
 
   @doc false
-  def parse_offset(""), do: {nil, ""}
-  def parse_offset("Z"), do: {0, ""}
-  def parse_offset("-00:00"), do: :error
-
+  def parse_offset(""),
+    do: {nil, ""}
+  def parse_offset("Z"),
+    do: {0, ""}
+  def parse_offset("-00:00"),
+    do: :error
   def parse_offset(<<?+, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
     do: parse_offset(1, hour, min, rest)
-
   def parse_offset(<<?-, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
     do: parse_offset(-1, hour, min, rest)
-
-  def parse_offset(<<?+, hour::2-bytes, min::2-bytes, rest::binary>>),
-    do: parse_offset(1, hour, min, rest)
-
-  def parse_offset(<<?-, hour::2-bytes, min::2-bytes, rest::binary>>),
-    do: parse_offset(-1, hour, min, rest)
-
-  def parse_offset(<<?+, hour::2-bytes, rest::binary>>), do: parse_offset(1, hour, "00", rest)
-  def parse_offset(<<?-, hour::2-bytes, rest::binary>>), do: parse_offset(-1, hour, "00", rest)
-  def parse_offset(_), do: :error
+  def parse_offset(_),
+    do: :error
 
   defp parse_offset(sign, hour, min, rest) do
     with {hour, ""} when hour < 24 <- Integer.parse(hour),
          {min, ""} when min < 60 <- Integer.parse(min) do
-      {(hour * 60 + min) * 60 * sign, rest}
+      {((hour * 60) + min) * 60 * sign, rest}
     else
       _ -> :error
     end
   end
-
-  @doc false
-  @doc since: "1.5.0"
-  def iso_days_to_unit({days, {parts, ppd}}, unit) do
-    day_microseconds = days * @parts_per_day
-    microseconds = div(parts * @parts_per_day, ppd)
-    System.convert_time_unit(day_microseconds + microseconds, :microsecond, unit)
-  end
-
-  @doc false
-  @doc since: "1.5.0"
-  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, ppd) do
-    normalize_iso_days(days, parts + add, ppd)
-  end
-
-  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, add_ppd) do
-    parts = parts * add_ppd
-    add = add * ppd
-    gcd = Integer.gcd(ppd, add_ppd)
-    result_parts = div(parts + add, gcd)
-    result_ppd = div(ppd * add_ppd, gcd)
-    normalize_iso_days(days, result_parts, result_ppd)
-  end
-
-  defp normalize_iso_days(days, parts, ppd) do
-    days_offset = div(parts, ppd)
-    parts = rem(parts, ppd)
-
-    if parts < 0 do
-      {days + days_offset - 1, {parts + ppd, ppd}}
-    else
-      {days + days_offset, {parts, ppd}}
-    end
-  end
-
-  # Note that this function does not add the extra leap day for a leap year.
-  # If you want to add that leap day when appropriate,
-  # add the result of leap_day_offset/2 to the result of days_before_month/1.
-  defp days_before_month(1), do: 0
-  defp days_before_month(2), do: 31
-  defp days_before_month(3), do: 59
-  defp days_before_month(4), do: 90
-  defp days_before_month(5), do: 120
-  defp days_before_month(6), do: 151
-  defp days_before_month(7), do: 181
-  defp days_before_month(8), do: 212
-  defp days_before_month(9), do: 243
-  defp days_before_month(10), do: 273
-  defp days_before_month(11), do: 304
-  defp days_before_month(12), do: 334
-
-  defp leap_day_offset(_year, month) when month < 3, do: 0
-
-  defp leap_day_offset(year, _month) do
-    if leap_year?(year), do: 1, else: 0
-  end
-
-  defp days_to_year(days) when days < 0 do
-    year_estimate = -div(-days, @days_per_nonleap_year) - 1
-
-    {year, days_before_year} =
-      days_to_year(year_estimate, days, days_to_end_of_epoch(year_estimate))
-
-    leap_year_pad = if leap_year?(year), do: 1, else: 0
-    {year, leap_year_pad + @days_per_nonleap_year + days - days_before_year}
-  end
-
-  defp days_to_year(days) do
-    year_estimate = div(days, @days_per_nonleap_year)
-
-    {year, days_before_year} =
-      days_to_year(year_estimate, days, days_in_previous_years(year_estimate))
-
-    {year, days - days_before_year}
-  end
-
-  defp days_to_year(year, days1, days2) when year < 0 and days1 >= days2 do
-    days_to_year(year + 1, days1, days_to_end_of_epoch(year + 1))
-  end
-
-  defp days_to_year(year, days1, days2) when year >= 0 and days1 < days2 do
-    days_to_year(year - 1, days1, days_in_previous_years(year - 1))
-  end
-
-  defp days_to_year(year, _days1, days2) do
-    {year, days2}
-  end
-
-  defp days_to_end_of_epoch(year) when year < 0 do
-    previous_year = year + 1
-
-    div(previous_year, 4) - div(previous_year, 100) + div(previous_year, 400) +
-      previous_year * @days_per_nonleap_year
-  end
-
-  defp days_in_previous_years(0), do: 0
-
-  defp days_in_previous_years(year) do
-    previous_year = year - 1
-
-    Integer.floor_div(previous_year, 4) - Integer.floor_div(previous_year, 100) +
-      Integer.floor_div(previous_year, 400) + previous_year * @days_per_nonleap_year +
-      @days_per_leap_year
-  end
-
-  # Note that 0 is the first day of the month.
-  defp year_day_to_year_date(_extra_day, day_of_year) when day_of_year < 31 do
-    {1, day_of_year}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 59 + extra_day do
-    {2, day_of_year - 31}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 90 + extra_day do
-    {3, day_of_year - (59 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 120 + extra_day do
-    {4, day_of_year - (90 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 151 + extra_day do
-    {5, day_of_year - (120 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 181 + extra_day do
-    {6, day_of_year - (151 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 212 + extra_day do
-    {7, day_of_year - (181 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 243 + extra_day do
-    {8, day_of_year - (212 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 273 + extra_day do
-    {9, day_of_year - (243 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 304 + extra_day do
-    {10, day_of_year - (273 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) when day_of_year < 334 + extra_day do
-    {11, day_of_year - (304 + extra_day)}
-  end
-
-  defp year_day_to_year_date(extra_day, day_of_year) do
-    {12, day_of_year - (334 + extra_day)}
-  end
-
-  defp iso_seconds_to_datetime(seconds) do
-    {days, rest_seconds} = div_mod(seconds, @seconds_per_day)
-
-    date = date_from_iso_days(days)
-    time = seconds_to_time(rest_seconds)
-    {date, time}
-  end
-
-  defp seconds_to_time(seconds) when seconds in 0..@last_second_of_the_day do
-    {hour, rest_seconds} = div_mod(seconds, @seconds_per_hour)
-    {minute, second} = div_mod(rest_seconds, @seconds_per_minute)
-
-    {hour, minute, second}
-  end
 end

lib/elixir/lib/calendar/naive_datetime.ex

@@ -1,920 +0,0 @@
-defmodule NaiveDateTime do
-  @moduledoc """
-  A NaiveDateTime struct (without a time zone) and functions.
-
-  The NaiveDateTime struct contains the fields year, month, day, hour,
-  minute, second, microsecond and calendar. New naive datetimes can be
-  built with the `new/2` and `new/8` functions or using the
-  [`~N`](`Kernel.sigil_N/2`) sigil:
-
-      iex> ~N[2000-01-01 23:00:07]
-      ~N[2000-01-01 23:00:07]
-
-  The date and time fields in the struct can be accessed directly:
-
-      iex> naive = ~N[2000-01-01 23:00:07]
-      iex> naive.year
-      2000
-      iex> naive.second
-      7
-
-  We call them "naive" because this datetime representation does not
-  have a time zone. This means the datetime may not actually exist in
-  certain areas in the world even though it is valid.
-
-  For example, when daylight saving changes are applied by a region,
-  the clock typically moves forward or backward by one hour. This means
-  certain datetimes never occur or may occur more than once. Since
-  `NaiveDateTime` is not validated against a time zone, such errors
-  would go unnoticed.
-
-  The functions of this module work with the `NaiveDateTime` struct as well
-  as any struct that contains the same fields as the `NaiveDateTime` struct,
-  such as `DateTime`. Such functions expect
-  `t:Calendar.naive_datetime/0` in their typespecs (instead of `t:t/0`).
-
-  Developers should avoid creating the NaiveDateTime structs directly
-  and instead, rely on the functions provided by this module as well
-  as the ones in 3rd party calendar libraries.
-
-  ## Comparing naive date times
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `NaiveDateTime` struct fields. For proper comparison
-  between naive datetimes, use the `compare/2` function.
-
-  ## Using epochs
-
-  The `add/3` and `diff/3` functions can be used for computing with
-  date times or retrieving the number of seconds between instants.
-  For example, if there is an interest in computing the number of
-  seconds from the Unix epoch (1970-01-01 00:00:00):
-
-      iex> NaiveDateTime.diff(~N[2010-04-17 14:00:00], ~N[1970-01-01 00:00:00])
-      1271512800
-
-      iex> NaiveDateTime.add(~N[1970-01-01 00:00:00], 1_271_512_800)
-      ~N[2010-04-17 14:00:00]
-
-  Those functions are optimized to deal with common epochs, such
-  as the Unix Epoch above or the Gregorian Epoch (0000-01-01 00:00:00).
-  """
-
-  @enforce_keys [:year, :month, :day, :hour, :minute, :second]
-  defstruct [
-    :year,
-    :month,
-    :day,
-    :hour,
-    :minute,
-    :second,
-    microsecond: {0, 0},
-    calendar: Calendar.ISO
-  ]
-
-  @type t :: %NaiveDateTime{
-          year: Calendar.year(),
-          month: Calendar.month(),
-          day: Calendar.day(),
-          calendar: Calendar.calendar(),
-          hour: Calendar.hour(),
-          minute: Calendar.minute(),
-          second: Calendar.second(),
-          microsecond: Calendar.microsecond()
-        }
-
-  @doc """
-  Returns the current naive datetime in UTC.
-
-  Prefer using `DateTime.utc_now/0` when possible as, opposite
-  to `NaiveDateTime`, it will keep the time zone information.
-
-  ## Examples
-
-      iex> naive_datetime = NaiveDateTime.utc_now()
-      iex> naive_datetime.year >= 2016
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_now(Calendar.calendar()) :: t
-  def utc_now(calendar \\ Calendar.ISO)
-
-  def utc_now(Calendar.ISO) do
-    {:ok, {year, month, day}, {hour, minute, second}, microsecond} =
-      Calendar.ISO.from_unix(:os.system_time(), :native)
-
-    %NaiveDateTime{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: Calendar.ISO
-    }
-  end
-
-  def utc_now(calendar) do
-    calendar
-    |> DateTime.utc_now()
-    |> DateTime.to_naive()
-  end
-
-  @doc """
-  Builds a new ISO naive datetime.
-
-  Expects all values to be integers. Returns `{:ok, naive_datetime}`
-  if each entry fits its appropriate range, returns `{:error, reason}`
-  otherwise.
-
-  ## Examples
-
-      iex> NaiveDateTime.new(2000, 1, 1, 0, 0, 0)
-      {:ok, ~N[2000-01-01 00:00:00]}
-      iex> NaiveDateTime.new(2000, 13, 1, 0, 0, 0)
-      {:error, :invalid_date}
-      iex> NaiveDateTime.new(2000, 2, 29, 0, 0, 0)
-      {:ok, ~N[2000-02-29 00:00:00]}
-      iex> NaiveDateTime.new(2000, 2, 30, 0, 0, 0)
-      {:error, :invalid_date}
-      iex> NaiveDateTime.new(2001, 2, 29, 0, 0, 0)
-      {:error, :invalid_date}
-
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1})
-      {:ok, ~N[2000-01-01 23:59:59.0]}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 999_999)
-      {:ok, ~N[2000-01-01 23:59:59.999999]}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 60, 999_999)
-      {:ok, ~N[2000-01-01 23:59:60.999999]}
-      iex> NaiveDateTime.new(2000, 1, 1, 24, 59, 59, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 60, 59, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 61, 999_999)
-      {:error, :invalid_time}
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, 1_000_000)
-      {:error, :invalid_time}
-
-      iex> NaiveDateTime.new(2000, 1, 1, 23, 59, 59, {0, 1}, Calendar.ISO)
-      {:ok, ~N[2000-01-01 23:59:59.0]}
-
-  """
-  @spec new(
-          Calendar.year(),
-          Calendar.month(),
-          Calendar.day(),
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond(),
-          Calendar.calendar()
-        ) :: {:ok, t} | {:error, atom}
-  def new(year, month, day, hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def new(year, month, day, hour, minute, second, microsecond, calendar)
-      when is_integer(microsecond) do
-    new(year, month, day, hour, minute, second, {microsecond, 6}, calendar)
-  end
-
-  def new(year, month, day, hour, minute, second, microsecond, calendar) do
-    cond do
-      not calendar.valid_date?(year, month, day) ->
-        {:error, :invalid_date}
-
-      not calendar.valid_time?(hour, minute, second, microsecond) ->
-        {:error, :invalid_time}
-
-      true ->
-        naive_datetime = %NaiveDateTime{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        }
-
-        {:ok, naive_datetime}
-    end
-  end
-
-  @doc """
-  Builds a naive datetime from date and time structs.
-
-  ## Examples
-
-      iex> NaiveDateTime.new(~D[2010-01-13], ~T[23:00:07.005])
-      {:ok, ~N[2010-01-13 23:00:07.005]}
-
-  """
-  @spec new(Date.t(), Time.t()) :: {:ok, t}
-  def new(date, time)
-
-  def new(%Date{calendar: calendar} = date, %Time{calendar: calendar} = time) do
-    %{year: year, month: month, day: day} = date
-    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
-
-    naive_datetime = %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, naive_datetime}
-  end
-
-  @doc """
-  Adds a specified amount of time to a `NaiveDateTime`.
-
-  Accepts an `integer` in any `unit` available from `t:System.time_unit/0`.
-  Negative values will move backwards in time.
-
-  This operation is only possible if both calendars are convertible to `Calendar.ISO`.
-
-  ## Examples
-
-      # adds seconds by default
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2)
-      ~N[2014-10-02 00:29:12]
-
-      # accepts negative offsets
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], -2)
-      ~N[2014-10-02 00:29:08]
-
-      # can work with other units
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10], 2_000, :millisecond)
-      ~N[2014-10-02 00:29:12]
-
-      # keeps the same precision
-      iex> NaiveDateTime.add(~N[2014-10-02 00:29:10.021], 21, :second)
-      ~N[2014-10-02 00:29:31.021]
-
-      # changes below the precision will not be visible
-      iex> hidden = NaiveDateTime.add(~N[2014-10-02 00:29:10], 21, :millisecond)
-      iex> hidden.microsecond # ~N[2014-10-02 00:29:10]
-      {21000, 0}
-
-      # from Gregorian seconds
-      iex> NaiveDateTime.add(~N[0000-01-01 00:00:00], 63_579_428_950)
-      ~N[2014-10-02 00:29:10]
-
-  """
-  @doc since: "1.4.0"
-  @spec add(t, integer, System.time_unit()) :: t
-  def add(%NaiveDateTime{} = naive_datetime, integer, unit \\ :second)
-      when is_integer(integer) do
-    %{microsecond: {_, precision}, calendar: calendar} = naive_datetime
-    ppd = System.convert_time_unit(86400, :second, unit)
-
-    naive_datetime
-    |> to_iso_days()
-    |> Calendar.ISO.add_day_fraction_to_iso_days(integer, ppd)
-    |> from_iso_days(calendar, precision)
-  end
-
-  @doc """
-  Subtracts `naive_datetime2` from `naive_datetime1`.
-
-  The answer can be returned in any `unit` available from `t:System.time_unit/0`.
-
-  This function returns the difference in seconds where seconds are measured
-  according to `Calendar.ISO`.
-
-  ## Examples
-
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10])
-      2
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:12], ~N[2014-10-02 00:29:10], :microsecond)
-      2_000_000
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10.042], ~N[2014-10-02 00:29:10.021], :millisecond)
-      21
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[2014-10-02 00:29:12])
-      -2
-      iex> NaiveDateTime.diff(~N[-0001-10-02 00:29:10], ~N[-0001-10-02 00:29:12])
-      -2
-
-      # to Gregorian seconds
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[0000-01-01 00:00:00])
-      63579428950
-
-  """
-  @doc since: "1.4.0"
-  @spec diff(t, t, System.time_unit()) :: integer
-  def diff(
-        %NaiveDateTime{} = naive_datetime1,
-        %NaiveDateTime{} = naive_datetime2,
-        unit \\ :second
-      ) do
-    if not Calendar.compatible_calendars?(naive_datetime1.calendar, naive_datetime2.calendar) do
-      raise ArgumentError,
-            "cannot calculate the difference between #{inspect(naive_datetime1)} and " <>
-              "#{inspect(naive_datetime2)} because their calendars are not compatible " <>
-              "and thus the result would be ambiguous"
-    end
-
-    units1 = naive_datetime1 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
-    units2 = naive_datetime2 |> to_iso_days() |> Calendar.ISO.iso_days_to_unit(unit)
-    units1 - units2
-  end
-
-  @doc """
-  Returns the given naive datetime with the microsecond field truncated to the
-  given precision (`:microsecond`, `:millisecond` or `:second`).
-
-  ## Examples
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :microsecond)
-      ~N[2017-11-06 00:23:51.123456]
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :millisecond)
-      ~N[2017-11-06 00:23:51.123]
-
-      iex> NaiveDateTime.truncate(~N[2017-11-06 00:23:51.123456], :second)
-      ~N[2017-11-06 00:23:51]
-
-  """
-  @doc since: "1.6.0"
-  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
-  def truncate(%NaiveDateTime{microsecond: microsecond} = naive_datetime, precision) do
-    %{naive_datetime | microsecond: Calendar.truncate(microsecond, precision)}
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` into a `Date`.
-
-  Because `Date` does not hold time information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_date(~N[2002-01-13 23:00:07])
-      ~D[2002-01-13]
-
-  """
-  @spec to_date(t) :: Date.t()
-  def to_date(%NaiveDateTime{year: year, month: month, day: day, calendar: calendar}) do
-    %Date{year: year, month: month, day: day, calendar: calendar}
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` into `Time`.
-
-  Because `Time` does not hold date information,
-  data will be lost during the conversion.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_time(~N[2002-01-13 23:00:07])
-      ~T[23:00:07]
-
-  """
-  @spec to_time(t) :: Time.t()
-  def to_time(%NaiveDateTime{} = naive_datetime) do
-    %{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    } = naive_datetime
-
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    }
-  end
-
-  @doc """
-  Converts the given naive datetime to a string according to its calendar.
-
-  ### Examples
-
-      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13])
-      "2000-02-28 23:00:13"
-      iex> NaiveDateTime.to_string(~N[2000-02-28 23:00:13.001])
-      "2000-02-28 23:00:13.001"
-      iex> NaiveDateTime.to_string(~N[-0100-12-15 03:20:31])
-      "-0100-12-15 03:20:31"
-
-  This function can also be used to convert a DateTime to a string without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_string(dt)
-      "2000-02-29 23:00:07"
-
-  """
-  @spec to_string(Calendar.naive_datetime()) :: String.t()
-  def to_string(%{calendar: calendar} = naive_datetime) do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = naive_datetime
-
-    calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Parses the extended "Date and time of day" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Time zone offset may be included in the string but they will be
-  simply discarded as such information is not included in naive date
-  times.
-
-  As specified in the standard, the separator "T" may be omitted if
-  desired as there is no ambiguity within this function.
-
-  Time representations with reduced accuracy are not supported.
-
-  Note that while ISO 8601 allows datetimes to specify 24:00:00 as the
-  zero hour of the next day, this notation is not supported by Elixir.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07")
-      {:ok, ~N[2015-01-23 23:50:07]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07")
-      {:ok, ~N[2015-01-23 23:50:07]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07Z")
-      {:ok, ~N[2015-01-23 23:50:07]}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0")
-      {:ok, ~N[2015-01-23 23:50:07.0]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07,0123456")
-      {:ok, ~N[2015-01-23 23:50:07.012345]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07.0123456")
-      {:ok, ~N[2015-01-23 23:50:07.012345]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123Z")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23P23:50:07")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015:01:23 23-50-07")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:07A")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23 23:50:61")
-      {:error, :invalid_time}
-      iex> NaiveDateTime.from_iso8601("2015-01-32 23:50:07")
-      {:error, :invalid_date}
-
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+02:30")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123+00:00")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-02:30")
-      {:ok, ~N[2015-01-23 23:50:07.123]}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:00")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-00:60")
-      {:error, :invalid_format}
-      iex> NaiveDateTime.from_iso8601("2015-01-23T23:50:07.123-24:00")
-      {:error, :invalid_format}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<?-, rest::binary>>, calendar) do
-    with {:ok, %{year: year} = naive_datetime} <- raw_from_iso8601(rest, calendar) do
-      {:ok, %{naive_datetime | year: -year}}
-    end
-  end
-
-  def from_iso8601(<<rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar)
-  end
-
-  @sep [?\s, ?T]
-  [match_date, guard_date, read_date] = Calendar.ISO.__match_date__()
-  [match_time, guard_time, read_time] = Calendar.ISO.__match_time__()
-
-  defp raw_from_iso8601(string, calendar) do
-    with <<unquote(match_date), sep, unquote(match_time), rest::binary>> <- string,
-         true <- unquote(guard_date) and sep in @sep and unquote(guard_time),
-         {microsec, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {_offset, ""} <- Calendar.ISO.parse_offset(rest) do
-      {year, month, day} = unquote(read_date)
-      {hour, min, sec} = unquote(read_time)
-
-      with {:ok, utc_date} <- new(year, month, day, hour, min, sec, microsec, Calendar.ISO) do
-        convert(utc_date, calendar)
-      end
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  @doc """
-  Parses the extended "Date and time of day" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07.123Z")
-      ~N[2015-01-23 23:50:07.123]
-      iex> NaiveDateTime.from_iso8601!("2015-01-23T23:50:07,123Z")
-      ~N[2015-01-23 23:50:07.123]
-      iex> NaiveDateTime.from_iso8601!("2015-01-23P23:50:07")
-      ** (ArgumentError) cannot parse "2015-01-23P23:50:07" as naive datetime, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t | no_return
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot parse #{inspect(string)} as naive datetime, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given naive datetime to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `NaiveDateTime.to_iso8601/2` returns naive datetimes formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through passing the `:basic` option.
-
-  Only supports converting naive datetimes which are in the ISO calendar,
-  attempting to convert naive datetimes from other calendars will raise.
-
-  ### Examples
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13])
-      "2000-02-28T23:00:13"
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001])
-      "2000-02-28T23:00:13.001"
-
-      iex> NaiveDateTime.to_iso8601(~N[2000-02-28 23:00:13.001], :basic)
-      "20000228T230013.001"
-
-  This function can also be used to convert a DateTime to ISO 8601 without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_iso8601(dt)
-      "2000-02-29T23:00:07"
-
-  """
-  @spec to_iso8601(Calendar.naive_datetime(), :basic | :extended) :: String.t()
-  def to_iso8601(naive_datetime, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = naive_datetime, format)
-      when format in [:basic, :extended] do
-    %{
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = naive_datetime
-
-    Calendar.ISO.naive_datetime_to_iso8601(
-      year,
-      month,
-      day,
-      hour,
-      minute,
-      second,
-      microsecond,
-      format
-    )
-  end
-
-  def to_iso8601(%{calendar: _} = naive_datetime, format) when format in [:basic, :extended] do
-    naive_datetime
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  @doc """
-  Converts a `NaiveDateTime` struct to an Erlang datetime tuple.
-
-  Only supports converting naive datetimes which are in the ISO calendar,
-  attempting to convert naive datetimes from other calendars will raise.
-
-  WARNING: Loss of precision may occur, as Erlang time tuples only store
-  hour/minute/second.
-
-  ## Examples
-
-      iex> NaiveDateTime.to_erl(~N[2000-01-01 13:30:15])
-      {{2000, 1, 1}, {13, 30, 15}}
-
-  This function can also be used to convert a DateTime to a erl format
-  without the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.to_erl(dt)
-      {{2000, 2, 29}, {23, 00, 07}}
-
-  """
-  @spec to_erl(Calendar.naive_datetime()) :: :calendar.datetime()
-  def to_erl(%{calendar: _} = naive_datetime) do
-    %{year: year, month: month, day: day, hour: hour, minute: minute, second: second} =
-      convert!(naive_datetime, Calendar.ISO)
-
-    {{year, month, day}, {hour, minute, second}}
-  end
-
-  @doc """
-  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
-
-  Attempting to convert an invalid ISO calendar date will produce an error tuple.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}})
-      {:ok, ~N[2000-01-01 13:30:15]}
-      iex> NaiveDateTime.from_erl({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
-      {:ok, ~N[2000-01-01 13:30:15.005]}
-      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
-      {:error, :invalid_date}
-      iex> NaiveDateTime.from_erl({{2000, 13, 1}, {13, 30, 15}})
-      {:error, :invalid_date}
-
-  """
-  @spec from_erl(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def from_erl({{year, month, day}, {hour, minute, second}}, microsecond, calendar) do
-    with {:ok, utc_date} <- new(year, month, day, hour, minute, second, microsecond),
-         do: convert(utc_date, calendar)
-  end
-
-  @doc """
-  Converts an Erlang datetime tuple to a `NaiveDateTime` struct.
-
-  Raises if the datetime is invalid.
-  Attempting to convert an invalid ISO calendar date will produce an error tuple.
-
-  ## Examples
-
-      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}})
-      ~N[2000-01-01 13:30:15]
-      iex> NaiveDateTime.from_erl!({{2000, 1, 1}, {13, 30, 15}}, {5000, 3})
-      ~N[2000-01-01 13:30:15.005]
-      iex> NaiveDateTime.from_erl!({{2000, 13, 1}, {13, 30, 15}})
-      ** (ArgumentError) cannot convert {{2000, 13, 1}, {13, 30, 15}} to naive datetime, reason: :invalid_date
-
-  """
-  @spec from_erl!(:calendar.datetime(), Calendar.microsecond(), Calendar.calendar()) ::
-          t | no_return
-  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, microsecond, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to naive datetime, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Compares two `NaiveDateTime` structs.
-
-  Returns `:gt` if first is later than the second
-  and `:lt` for vice versa. If the two NaiveDateTime
-  are equal `:eq` is returned.
-
-  ## Examples
-
-      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15], ~N[2016-04-28 16:19:25])
-      :lt
-      iex> NaiveDateTime.compare(~N[2016-04-16 13:30:15.1], ~N[2016-04-16 13:30:15.01])
-      :gt
-
-  This function can also be used to compare a DateTime without
-  the time zone information:
-
-      iex> dt = %DateTime{year: 2000, month: 2, day: 29, zone_abbr: "CET",
-      ...>                hour: 23, minute: 0, second: 7, microsecond: {0, 0},
-      ...>                utc_offset: 3600, std_offset: 0, time_zone: "Europe/Warsaw"}
-      iex> NaiveDateTime.compare(dt, ~N[2000-02-29 23:00:07])
-      :eq
-      iex> NaiveDateTime.compare(dt, ~N[2000-01-29 23:00:07])
-      :gt
-      iex> NaiveDateTime.compare(dt, ~N[2000-03-29 23:00:07])
-      :lt
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.naive_datetime(), Calendar.naive_datetime()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar1} = naive_datetime1, %{calendar: calendar2} = naive_datetime2) do
-    if Calendar.compatible_calendars?(calendar1, calendar2) do
-      case {to_iso_days(naive_datetime1), to_iso_days(naive_datetime2)} do
-        {first, second} when first > second -> :gt
-        {first, second} when first < second -> :lt
-        _ -> :eq
-      end
-    else
-      raise ArgumentError, """
-      cannot compare #{inspect(naive_datetime1)} with #{inspect(naive_datetime2)}.
-
-      This comparison would be ambiguous as their calendars have incompatible day rollover moments.
-      Specify an exact time of day (using `DateTime`s) to resolve this ambiguity
-      """
-    end
-  end
-
-  @doc """
-  Converts the given `naive_datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an `{:error, :incompatible_calendars}` tuple
-  is returned.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> NaiveDateTime.convert(~N[2000-01-01 13:30:15], Calendar.Holocene)
-      {:ok, %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
-                           hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.naive_datetime(), Calendar.calendar()) ::
-          {:ok, t} | {:error, :incompatible_calendars}
-
-  # Keep it multiline for proper function clause errors.
-  def convert(
-        %{
-          calendar: calendar,
-          year: year,
-          month: month,
-          day: day,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        calendar
-      ) do
-    naive_datetime = %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, naive_datetime}
-  end
-
-  def convert(%{calendar: ndt_calendar, microsecond: {_, precision}} = naive_datetime, calendar) do
-    if Calendar.compatible_calendars?(ndt_calendar, calendar) do
-      result_naive_datetime =
-        naive_datetime
-        |> to_iso_days
-        |> from_iso_days(calendar, precision)
-
-      {:ok, result_naive_datetime}
-    else
-      {:error, :incompatible_calendars}
-    end
-  end
-
-  @doc """
-  Converts the given `naive_datetime` from one calendar to another.
-
-  If it is not possible to convert unambiguously between the calendars
-  (see `Calendar.compatible_calendars?/2`), an ArgumentError is raised.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> NaiveDateTime.convert!(~N[2000-01-01 13:30:15], Calendar.Holocene)
-      %NaiveDateTime{calendar: Calendar.Holocene, year: 12000, month: 1, day: 1,
-                     hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.naive_datetime(), Calendar.calendar()) :: t
-  def convert!(naive_datetime, calendar) do
-    case convert(naive_datetime, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, :incompatible_calendars} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(naive_datetime)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(naive_datetime.calendar)} and #{inspect(calendar)} " <>
-                "have different day rollover moments, making this conversion ambiguous"
-    end
-  end
-
-  ## Helpers
-
-  # Keep it multiline for proper function clause errors.
-  defp to_iso_days(%{
-         calendar: calendar,
-         year: year,
-         month: month,
-         day: day,
-         hour: hour,
-         minute: minute,
-         second: second,
-         microsecond: microsecond
-       }) do
-    calendar.naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond)
-  end
-
-  defp from_iso_days(iso_days, calendar, precision) do
-    {year, month, day, hour, minute, second, {microsecond, _}} =
-      calendar.naive_datetime_from_iso_days(iso_days)
-
-    %NaiveDateTime{
-      calendar: calendar,
-      year: year,
-      month: month,
-      day: day,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision}
-    }
-  end
-
-  defimpl String.Chars do
-    def to_string(naive_datetime) do
-      %{
-        calendar: calendar,
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond
-      } = naive_datetime
-
-      calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: Calendar.ISO} = naive_datetime, _) do
-      %{
-        year: year,
-        month: month,
-        day: day,
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond
-      } = naive_datetime
-
-      formatted =
-        Calendar.ISO.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-
-      "~N[" <> formatted <> "]"
-    end
-
-    def inspect(naive, opts) do
-      Inspect.Any.inspect(naive, opts)
-    end
-  end
-end

lib/elixir/lib/calendar/time.ex

@@ -1,673 +0,0 @@
-defmodule Time do
-  @moduledoc """
-  A Time struct and functions.
-
-  The Time struct contains the fields hour, minute, second and microseconds.
-  New times can be built with the `new/4` function or using the
-  [`~T`](`Kernel.sigil_T/2`) sigil:
-
-      iex> ~T[23:00:07.001]
-      ~T[23:00:07.001]
-
-  Both `new/4` and sigil return a struct where the time fields can
-  be accessed directly:
-
-      iex> time = ~T[23:00:07.001]
-      iex> time.hour
-      23
-      iex> time.microsecond
-      {1000, 3}
-
-  The functions on this module work with the `Time` struct as well
-  as any struct that contains the same fields as the `Time` struct,
-  such as `NaiveDateTime` and `DateTime`. Such functions expect
-  `t:Calendar.time/0` in their typespecs (instead of `t:t/0`).
-
-  Developers should avoid creating the Time structs directly
-  and instead rely on the functions provided by this module as well
-  as the ones in 3rd party calendar libraries.
-
-  ## Comparing times
-
-  Comparisons in Elixir using `==/2`, `>/2`, `</2` and similar are structural
-  and based on the `Time` struct fields. For proper comparison between
-  times, use the `compare/2` function.
-  """
-
-  @enforce_keys [:hour, :minute, :second]
-  defstruct [:hour, :minute, :second, microsecond: {0, 0}, calendar: Calendar.ISO]
-
-  @type t :: %Time{
-          hour: Calendar.hour(),
-          minute: Calendar.minute(),
-          second: Calendar.second(),
-          microsecond: Calendar.microsecond(),
-          calendar: Calendar.calendar()
-        }
-
-  @doc """
-  Returns the current time in UTC.
-
-  ## Examples
-
-      iex> time = Time.utc_now()
-      iex> time.hour >= 0
-      true
-
-  """
-  @doc since: "1.4.0"
-  @spec utc_now(Calendar.calendar()) :: t
-  def utc_now(calendar \\ Calendar.ISO) do
-    {:ok, _, time, microsecond} = Calendar.ISO.from_unix(:os.system_time(), :native)
-    {hour, minute, second} = time
-
-    iso_time = %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: Calendar.ISO
-    }
-
-    convert!(iso_time, calendar)
-  end
-
-  @doc """
-  Builds a new time.
-
-  Expects all values to be integers. Returns `{:ok, time}` if each
-  entry fits its appropriate range, returns `{:error, reason}` otherwise.
-
-  Note a time may have 60 seconds in case of leap seconds. Microseconds
-  can also be given with a precision, which must be an integer between
-  0 and 6.
-
-  ## Examples
-
-      iex> Time.new(0, 0, 0, 0)
-      {:ok, ~T[00:00:00.000000]}
-      iex> Time.new(23, 59, 59, 999_999)
-      {:ok, ~T[23:59:59.999999]}
-      iex> Time.new(23, 59, 60, 999_999)
-      {:ok, ~T[23:59:60.999999]}
-
-      # Time with microseconds and their precision
-      iex> Time.new(23, 59, 60, {10_000, 2})
-      {:ok, ~T[23:59:60.01]}
-
-      iex> Time.new(24, 59, 59, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 60, 59, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 59, 61, 999_999)
-      {:error, :invalid_time}
-      iex> Time.new(23, 59, 59, 1_000_000)
-      {:error, :invalid_time}
-
-      # Invalid precision
-      Time.new(23, 59, 59, {999_999, 10})
-      {:error, :invalid_time}
-
-  """
-  @spec new(
-          Calendar.hour(),
-          Calendar.minute(),
-          Calendar.second(),
-          Calendar.microsecond() | integer,
-          Calendar.calendar()
-        ) :: {:ok, t} | {:error, atom}
-  def new(hour, minute, second, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def new(hour, minute, second, microsecond, calendar) when is_integer(microsecond) do
-    new(hour, minute, second, {microsecond, 6}, calendar)
-  end
-
-  def new(hour, minute, second, {microsecond, precision}, calendar)
-      when is_integer(hour) and is_integer(minute) and is_integer(second) and
-             is_integer(microsecond) and is_integer(precision) do
-    case calendar.valid_time?(hour, minute, second, {microsecond, precision}) do
-      true ->
-        time = %Time{
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: {microsecond, precision},
-          calendar: calendar
-        }
-
-        {:ok, time}
-
-      false ->
-        {:error, :invalid_time}
-    end
-  end
-
-  @doc """
-  Converts the given `time` to a string.
-
-  ### Examples
-
-      iex> Time.to_string(~T[23:00:00])
-      "23:00:00"
-      iex> Time.to_string(~T[23:00:00.001])
-      "23:00:00.001"
-      iex> Time.to_string(~T[23:00:00.123456])
-      "23:00:00.123456"
-
-      iex> Time.to_string(~N[2015-01-01 23:00:00.001])
-      "23:00:00.001"
-      iex> Time.to_string(~N[2015-01-01 23:00:00.123456])
-      "23:00:00.123456"
-
-  """
-  @spec to_string(Calendar.time()) :: String.t()
-  def to_string(time)
-
-  def to_string(%{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      }) do
-    calendar.time_to_string(hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Parses the extended "Local time" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Time zone offset may be included in the string but they will be
-  simply discarded as such information is not included in times.
-
-  As specified in the standard, the separator "T" may be omitted if
-  desired as there is no ambiguity within this function.
-
-  Time representations with reduced accuracy are not supported.
-
-  Note that while ISO 8601 allows times to specify 24:00:00 as the
-  zero hour of the next day, this notation is not supported by Elixir.
-
-  ## Examples
-
-      iex> Time.from_iso8601("23:50:07")
-      {:ok, ~T[23:50:07]}
-      iex> Time.from_iso8601("23:50:07Z")
-      {:ok, ~T[23:50:07]}
-      iex> Time.from_iso8601("T23:50:07Z")
-      {:ok, ~T[23:50:07]}
-
-      iex> Time.from_iso8601("23:50:07,0123456")
-      {:ok, ~T[23:50:07.012345]}
-      iex> Time.from_iso8601("23:50:07.0123456")
-      {:ok, ~T[23:50:07.012345]}
-      iex> Time.from_iso8601("23:50:07.123Z")
-      {:ok, ~T[23:50:07.123]}
-
-      iex> Time.from_iso8601("2015:01:23 23-50-07")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:07A")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:07.")
-      {:error, :invalid_format}
-      iex> Time.from_iso8601("23:50:61")
-      {:error, :invalid_time}
-
-  """
-  @spec from_iso8601(String.t(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<?T, rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar)
-  end
-
-  def from_iso8601(<<rest::binary>>, calendar) do
-    raw_from_iso8601(rest, calendar)
-  end
-
-  [match_time, guard_time, read_time] = Calendar.ISO.__match_time__()
-
-  defp raw_from_iso8601(string, calendar) do
-    with <<unquote(match_time), rest::binary>> <- string,
-         true <- unquote(guard_time),
-         {microsec, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {_offset, ""} <- Calendar.ISO.parse_offset(rest) do
-      {hour, min, sec} = unquote(read_time)
-
-      with {:ok, utc_time} <- new(hour, min, sec, microsec, Calendar.ISO) do
-        convert(utc_time, calendar)
-      end
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  @doc """
-  Parses the extended "Local time" format described by
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  Raises if the format is invalid.
-
-  ## Examples
-
-      iex> Time.from_iso8601!("23:50:07,123Z")
-      ~T[23:50:07.123]
-      iex> Time.from_iso8601!("23:50:07.123Z")
-      ~T[23:50:07.123]
-      iex> Time.from_iso8601!("2015:01:23 23-50-07")
-      ** (ArgumentError) cannot parse "2015:01:23 23-50-07" as time, reason: :invalid_format
-
-  """
-  @spec from_iso8601!(String.t(), Calendar.calendar()) :: t
-  def from_iso8601!(string, calendar \\ Calendar.ISO) do
-    case from_iso8601(string, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError, "cannot parse #{inspect(string)} as time, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Converts the given time to
-  [ISO 8601:2004](https://en.wikipedia.org/wiki/ISO_8601).
-
-  By default, `Time.to_iso8601/2` returns times formatted in the "extended"
-  format, for human readability. It also supports the "basic" format through
-  passing the `:basic` option.
-
-  ### Examples
-
-      iex> Time.to_iso8601(~T[23:00:13])
-      "23:00:13"
-
-      iex> Time.to_iso8601(~T[23:00:13.001])
-      "23:00:13.001"
-
-      iex> Time.to_iso8601(~T[23:00:13.001], :basic)
-      "230013.001"
-
-      iex> Time.to_iso8601(~N[2010-04-17 23:00:13])
-      "23:00:13"
-
-  """
-  @spec to_iso8601(Calendar.time(), :extended | :basic) :: String.t()
-  def to_iso8601(time, format \\ :extended)
-
-  def to_iso8601(%{calendar: Calendar.ISO} = time, format) when format in [:extended, :basic] do
-    %{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    } = time
-
-    Calendar.ISO.time_to_iso8601(hour, minute, second, microsecond, format)
-  end
-
-  def to_iso8601(%{calendar: _} = time, format) when format in [:extended, :basic] do
-    time
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  @doc """
-  Converts given `time` to an Erlang time tuple.
-
-  WARNING: Loss of precision may occur, as Erlang time tuples
-  only contain hours/minutes/seconds.
-
-  ## Examples
-
-      iex> Time.to_erl(~T[23:30:15.999])
-      {23, 30, 15}
-
-      iex> Time.to_erl(~N[2010-04-17 23:30:15.999])
-      {23, 30, 15}
-
-  """
-  @spec to_erl(Calendar.time()) :: :calendar.time()
-  def to_erl(time) do
-    %{hour: hour, minute: minute, second: second} = convert!(time, Calendar.ISO)
-    {hour, minute, second}
-  end
-
-  @doc """
-  Converts an Erlang time tuple to a `Time` struct.
-
-  ## Examples
-
-      iex> Time.from_erl({23, 30, 15}, {5000, 3})
-      {:ok, ~T[23:30:15.005]}
-      iex> Time.from_erl({24, 30, 15})
-      {:error, :invalid_time}
-
-  """
-  @spec from_erl(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) ::
-          {:ok, t} | {:error, atom}
-  def from_erl(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO)
-
-  def from_erl({hour, minute, second}, microsecond, calendar) do
-    with {:ok, time} <- new(hour, minute, second, microsecond, Calendar.ISO),
-         do: convert(time, calendar)
-  end
-
-  @doc """
-  Converts an Erlang time tuple to a `Time` struct.
-
-  ## Examples
-
-      iex> Time.from_erl!({23, 30, 15})
-      ~T[23:30:15]
-      iex> Time.from_erl!({23, 30, 15}, {5000, 3})
-      ~T[23:30:15.005]
-      iex> Time.from_erl!({24, 30, 15})
-      ** (ArgumentError) cannot convert {24, 30, 15} to time, reason: :invalid_time
-
-  """
-  @spec from_erl!(:calendar.time(), Calendar.microsecond(), Calendar.calendar()) :: t
-  def from_erl!(tuple, microsecond \\ {0, 0}, calendar \\ Calendar.ISO) do
-    case from_erl(tuple, microsecond, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(tuple)} to time, reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Adds the `number` of `unit`s to the given `time`.
-
-  This function accepts the `number` measured according to `Calendar.ISO`.
-  The time is returned in the same calendar as it was given in.
-
-  Note the result value represents the time of day, meaning that it is cyclic,
-  for instance, it will never go over 24 hours for the ISO calendar.
-
-  ## Examples
-
-      iex> Time.add(~T[10:00:00], 27000)
-      ~T[17:30:00.000000]
-      iex> Time.add(~T[11:00:00.005], 2400)
-      ~T[11:40:00.005000]
-      iex> Time.add(~T[00:00:00], 86_399_999, :millisecond)
-      ~T[23:59:59.999000]
-      iex> Time.add(~T[17:10:05], 86400)
-      ~T[17:10:05.000000]
-      iex> Time.add(~T[23:00:00], -60)
-      ~T[22:59:00.000000]
-
-  """
-  @doc since: "1.6.0"
-  @spec add(Calendar.time(), integer, System.time_unit()) :: t
-  def add(%{calendar: calendar} = time, number, unit \\ :second) when is_integer(number) do
-    number = System.convert_time_unit(number, unit, :microsecond)
-    iso_days = {0, to_day_fraction(time)}
-    total = Calendar.ISO.iso_days_to_unit(iso_days, :microsecond) + number
-    iso_ppd = 86_400_000_000
-    parts = Integer.mod(total, iso_ppd)
-
-    {hour, minute, second, microsecond} = calendar.time_from_day_fraction({parts, iso_ppd})
-
-    %Time{
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond,
-      calendar: calendar
-    }
-  end
-
-  @doc """
-  Compares two time structs.
-
-  Returns `:gt` if first time is later than the second
-  and `:lt` for vice versa. If the two times are equal
-  `:eq` is returned.
-
-  ## Examples
-
-      iex> Time.compare(~T[16:04:16], ~T[16:04:28])
-      :lt
-      iex> Time.compare(~T[16:04:16], ~T[16:04:16])
-      :eq
-      iex> Time.compare(~T[16:04:16.01], ~T[16:04:16.001])
-      :gt
-
-  This function can also be used to compare across more
-  complex calendar types by considering only the time fields:
-
-      iex> Time.compare(~N[1900-01-01 16:04:16], ~N[2015-01-01 16:04:16])
-      :eq
-      iex> Time.compare(~N[2015-01-01 16:04:16], ~N[2015-01-01 16:04:28])
-      :lt
-      iex> Time.compare(~N[2015-01-01 16:04:16.01], ~N[2000-01-01 16:04:16.001])
-      :gt
-
-  """
-  @doc since: "1.4.0"
-  @spec compare(Calendar.time(), Calendar.time()) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar} = time1, %{calendar: calendar} = time2) do
-    %{hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}} = time1
-    %{hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}} = time2
-
-    case {{hour1, minute1, second1, microsecond1}, {hour2, minute2, second2, microsecond2}} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  def compare(time1, time2) do
-    {parts1, ppd1} = to_day_fraction(time1)
-    {parts2, ppd2} = to_day_fraction(time2)
-
-    case {parts1 * ppd2, parts2 * ppd1} do
-      {first, second} when first > second -> :gt
-      {first, second} when first < second -> :lt
-      _ -> :eq
-    end
-  end
-
-  @doc """
-  Converts given `time` to a different calendar.
-
-  Returns `{:ok, time}` if the conversion was successful,
-  or `{:error, reason}` if it was not, for some reason.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Time.convert(~T[13:30:15], Calendar.Holocene)
-      {:ok, %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert(Calendar.time(), Calendar.calendar()) :: {:ok, t} | {:error, atom}
-
-  # Keep it multiline for proper function clause errors.
-  def convert(
-        %{
-          calendar: calendar,
-          hour: hour,
-          minute: minute,
-          second: second,
-          microsecond: microsecond
-        },
-        calendar
-      ) do
-    time = %Time{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: microsecond
-    }
-
-    {:ok, time}
-  end
-
-  def convert(%{microsecond: {_, precision}} = time, calendar) do
-    {hour, minute, second, {microsecond, _}} =
-      time
-      |> to_day_fraction()
-      |> calendar.time_from_day_fraction()
-
-    time = %Time{
-      calendar: calendar,
-      hour: hour,
-      minute: minute,
-      second: second,
-      microsecond: {microsecond, precision}
-    }
-
-    {:ok, time}
-  end
-
-  @doc """
-  Similar to `Time.convert/2`, but raises an `ArgumentError`
-  if the conversion between the two calendars is not possible.
-
-  ## Examples
-
-  Imagine someone implements `Calendar.Holocene`, a calendar based on the
-  Gregorian calendar that adds exactly 10,000 years to the current Gregorian
-  year:
-
-      iex> Time.convert!(~T[13:30:15], Calendar.Holocene)
-      %Time{calendar: Calendar.Holocene, hour: 13, minute: 30, second: 15, microsecond: {0, 0}}
-
-  """
-  @doc since: "1.5.0"
-  @spec convert!(Calendar.time(), Calendar.calendar()) :: t
-  def convert!(time, calendar) do
-    case convert(time, calendar) do
-      {:ok, value} ->
-        value
-
-      {:error, reason} ->
-        raise ArgumentError,
-              "cannot convert #{inspect(time)} to target calendar #{inspect(calendar)}, " <>
-                "reason: #{inspect(reason)}"
-    end
-  end
-
-  @doc """
-  Returns the difference between two times, considering only the hour, minute,
-  second and microsecond.
-
-  As with the `compare/2` function both `Time` structs and other structures
-  containing time can be used. If for instance a `NaiveDateTime` or `DateTime`
-  is passed, only the hour, month, second, and microsecond is considered. Any
-  additional information about a date or time zone is ignored when calculating
-  the difference.
-
-  The answer can be returned in any `unit` available from
-  `t:System.time_unit/0`. If the first unit is smaller than
-  the second, a negative number is returned.
-
-  This function returns the difference in seconds where seconds
-  are measured according to `Calendar.ISO`.
-
-  ## Examples
-
-      iex> Time.diff(~T[00:29:12], ~T[00:29:10])
-      2
-
-      # When passing a `NaiveDateTime` the date part is ignored.
-      iex> Time.diff(~N[2017-01-01 00:29:12], ~T[00:29:10])
-      2
-
-      # Two `NaiveDateTime` structs could have big differences in the date
-      # but only the time part is considered.
-      iex> Time.diff(~N[2017-01-01 00:29:12], ~N[1900-02-03 00:29:10])
-      2
-
-      iex> Time.diff(~T[00:29:12], ~T[00:29:10], :microsecond)
-      2_000_000
-      iex> Time.diff(~T[00:29:10], ~T[00:29:12], :microsecond)
-      -2_000_000
-
-  """
-  @doc since: "1.5.0"
-  @spec diff(Calendar.time(), Calendar.time(), System.time_unit()) :: integer
-  def diff(time1, time2, unit \\ :second) do
-    fraction1 = to_day_fraction(time1)
-    fraction2 = to_day_fraction(time2)
-
-    Calendar.ISO.iso_days_to_unit({0, fraction1}, unit) -
-      Calendar.ISO.iso_days_to_unit({0, fraction2}, unit)
-  end
-
-  @doc """
-  Returns the given time with the microsecond field truncated to the given
-  precision (`:microsecond`, `millisecond` or `:second`).
-
-  ## Examples
-
-      iex> Time.truncate(~T[01:01:01.123456], :microsecond)
-      ~T[01:01:01.123456]
-
-      iex> Time.truncate(~T[01:01:01.123456], :millisecond)
-      ~T[01:01:01.123]
-
-      iex> Time.truncate(~T[01:01:01.123456], :second)
-      ~T[01:01:01]
-
-  """
-  @doc since: "1.6.0"
-  @spec truncate(t(), :microsecond | :millisecond | :second) :: t()
-  def truncate(%Time{microsecond: microsecond} = time, precision) do
-    %{time | microsecond: Calendar.truncate(microsecond, precision)}
-  end
-
-  ## Helpers
-
-  defp to_day_fraction(%{
-         hour: hour,
-         minute: minute,
-         second: second,
-         microsecond: {_, _} = microsecond,
-         calendar: calendar
-       }) do
-    calendar.time_to_day_fraction(hour, minute, second, microsecond)
-  end
-
-  defimpl String.Chars do
-    def to_string(time) do
-      %{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: calendar
-      } = time
-
-      calendar.time_to_string(hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: Calendar.ISO} = time, _) do
-      %{
-        hour: hour,
-        minute: minute,
-        second: second,
-        microsecond: microsecond,
-        calendar: Calendar.ISO
-      } = time
-
-      "~T[" <> Calendar.ISO.time_to_string(hour, minute, second, microsecond) <> "]"
-    end
-
-    def inspect(time, opts) do
-      Inspect.Any.inspect(time, opts)
-    end
-  end
-end

lib/elixir/lib/code/identifier.ex

@@ -1,281 +0,0 @@
-defmodule Code.Identifier do
-  @moduledoc false
-
-  @doc """
-  Checks if the given identifier is an unary op.
-
-  ## Examples
-
-      iex> Code.Identifier.unary_op(:+)
-      {:non_associative, 300}
-
-  """
-  @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error
-  def unary_op(op) do
-    cond do
-      op in [:&] -> {:non_associative, 90}
-      op in [:!, :^, :not, :+, :-, :~~~] -> {:non_associative, 300}
-      op in [:@] -> {:non_associative, 320}
-      true -> :error
-    end
-  end
-
-  @doc """
-  Checks if the given identifier is a binary op.
-
-  ## Examples
-
-      iex> Code.Identifier.binary_op(:+)
-      {:left, 210}
-
-  """
-  @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error
-  def binary_op(op) do
-    cond do
-      op in [:<-, :\\] -> {:left, 40}
-      op in [:when] -> {:right, 50}
-      op in [:::] -> {:right, 60}
-      op in [:|] -> {:right, 70}
-      op in [:=] -> {:right, 100}
-      op in [:||, :|||, :or] -> {:left, 130}
-      op in [:&&, :&&&, :and] -> {:left, 140}
-      op in [:==, :!=, :=~, :===, :!==] -> {:left, 150}
-      op in [:<, :<=, :>=, :>] -> {:left, 160}
-      op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :<|>] -> {:left, 170}
-      op in [:in] -> {:left, 180}
-      op in [:^^^] -> {:left, 190}
-      op in [:++, :--, :.., :<>] -> {:right, 200}
-      op in [:+, :-] -> {:left, 210}
-      op in [:*, :/] -> {:left, 220}
-      op in [:.] -> {:left, 310}
-      true -> :error
-    end
-  end
-
-  @doc """
-  Classifies the given atom into one of the following categories:
-
-    * `:alias` - a valid Elixir alias, like `Foo`, `Foo.Bar` and so on
-
-    * `:callable_local` - an atom that can be used as a local call;
-      this category includes identifiers like `:foo`
-
-    * `:callable_operators` - all callable operators, such as `:<>`. Note
-      operators such as `:..` are not callable because of ambiguity
-
-    * `:not_callable` - an atom that cannot be used as a function call after the
-      `.` operator (for example, `:<<>>` is not callable because `Foo.<<>>` is a
-      syntax error); this category includes atoms like `:Foo`, since they are
-      valid identifiers but they need quotes to be used in function calls
-      (`Foo."Bar"`)
-
-    * `:other` - any other atom (these are usually escaped when inspected, like
-      `:"foo and bar"`)
-
-  """
-  def classify(atom) when is_atom(atom) do
-    charlist = Atom.to_charlist(atom)
-
-    cond do
-      atom in [:%, :%{}, :{}, :<<>>, :..., :.., :., :->] ->
-        :not_callable
-
-      unary_op(atom) != :error or binary_op(atom) != :error ->
-        :callable_operator
-
-      valid_alias?(charlist) ->
-        :alias
-
-      true ->
-        case :elixir_config.safe_get(:identifier_tokenizer, String.Tokenizer).tokenize(charlist) do
-          {kind, _acc, [], _, _, special} ->
-            if kind == :identifier and not :lists.member(?@, special) do
-              :callable_local
-            else
-              :not_callable
-            end
-
-          _ ->
-            :other
-        end
-    end
-  end
-
-  defp valid_alias?('Elixir' ++ rest), do: valid_alias_piece?(rest)
-  defp valid_alias?(_other), do: false
-
-  defp valid_alias_piece?([?., char | rest]) when char >= ?A and char <= ?Z,
-    do: valid_alias_piece?(trim_leading_while_valid_identifier(rest))
-
-  defp valid_alias_piece?([]), do: true
-  defp valid_alias_piece?(_other), do: false
-
-  defp trim_leading_while_valid_identifier([char | rest])
-       when char >= ?a and char <= ?z
-       when char >= ?A and char <= ?Z
-       when char >= ?0 and char <= ?9
-       when char == ?_ do
-    trim_leading_while_valid_identifier(rest)
-  end
-
-  defp trim_leading_while_valid_identifier(other) do
-    other
-  end
-
-  @doc """
-  Inspects the identifier as an atom.
-  """
-  def inspect_as_atom(atom) when is_nil(atom) or is_boolean(atom) do
-    Atom.to_string(atom)
-  end
-
-  def inspect_as_atom(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      :alias ->
-        case binary do
-          binary when binary in ["Elixir", "Elixir.Elixir"] -> binary
-          "Elixir.Elixir." <> _rest -> binary
-          "Elixir." <> rest -> rest
-        end
-
-      type when type in [:callable_local, :callable_operator, :not_callable] ->
-        ":" <> binary
-
-      :other ->
-        {escaped, _} = escape(binary, ?")
-        IO.iodata_to_binary([?:, ?", escaped, ?"])
-    end
-  end
-
-  @doc """
-  Inspects the given identifier as a key.
-  """
-  def inspect_as_key(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      type when type in [:callable_local, :callable_operator, :not_callable] ->
-        IO.iodata_to_binary([binary, ?:])
-
-      _ ->
-        {escaped, _} = escape(binary, ?")
-        IO.iodata_to_binary([?", escaped, ?", ?:])
-    end
-  end
-
-  @doc """
-  Inspects the given identifier as a function name.
-  """
-  def inspect_as_function(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case classify(atom) do
-      type when type in [:callable_local, :callable_operator] ->
-        binary
-
-      type ->
-        escaped =
-          if type in [:not_callable, :alias] do
-            binary
-          else
-            elem(escape(binary, ?"), 0)
-          end
-
-        IO.iodata_to_binary([?", escaped, ?"])
-    end
-  end
-
-  @doc """
-  Extracts the name and arity of the parent from the anonymous function identifier.
-  """
-  # Example of this format: -NAME/ARITY-fun-COUNT-
-  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
-    with "-" <> rest <- Atom.to_string(atom),
-         [trailing | reversed] = rest |> String.split("/") |> Enum.reverse(),
-         [arity, _inner, _count, ""] <- String.split(trailing, "-") do
-      {reversed |> Enum.reverse() |> Enum.join("/") |> String.to_atom(), arity}
-    else
-      _ -> :error
-    end
-  end
-
-  @doc """
-  Escapes the given identifier.
-  """
-  def escape(other, char, count \\ :infinity, fun \\ &escape_map/1) do
-    escape(other, char, count, [], fun)
-  end
-
-  defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do
-    {acc, binary}
-  end
-
-  defp escape(<<char, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | [?\\, char]], fun)
-  end
-
-  defp escape(<<?#, ?{, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | '\\\#{'], fun)
-  end
-
-  defp escape(<<h::utf8, t::binary>>, char, count, acc, fun) do
-    escaped = if value = fun.(h), do: value, else: escape_char(h)
-    escape(t, char, decrement(count), [acc | escaped], fun)
-  end
-
-  defp escape(<<a::4, b::4, t::binary>>, char, count, acc, fun) do
-    escape(t, char, decrement(count), [acc | ['\\x', to_hex(a), to_hex(b)]], fun)
-  end
-
-  defp escape(<<>>, _char, _count, acc, _fun) do
-    {acc, <<>>}
-  end
-
-  defp escape_char(0), do: '\\0'
-
-  defp escape_char(65279), do: '\\uFEFF'
-
-  defp escape_char(char)
-       when char in 0x20..0x7E
-       when char in 0xA0..0xD7FF
-       when char in 0xE000..0xFFFD
-       when char in 0x10000..0x10FFFF do
-    <<char::utf8>>
-  end
-
-  defp escape_char(char) when char < 0x100 do
-    <<a::4, b::4>> = <<char::8>>
-    ['\\x', to_hex(a), to_hex(b)]
-  end
-
-  defp escape_char(char) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}]
-  end
-
-  defp escape_char(char) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), to_hex(e), to_hex(f), ?}]
-  end
-
-  defp escape_map(?\a), do: '\\a'
-  defp escape_map(?\b), do: '\\b'
-  defp escape_map(?\d), do: '\\d'
-  defp escape_map(?\e), do: '\\e'
-  defp escape_map(?\f), do: '\\f'
-  defp escape_map(?\n), do: '\\n'
-  defp escape_map(?\r), do: '\\r'
-  defp escape_map(?\t), do: '\\t'
-  defp escape_map(?\v), do: '\\v'
-  defp escape_map(?\\), do: '\\\\'
-  defp escape_map(_), do: false
-
-  @compile {:inline, to_hex: 1, decrement: 1}
-  defp to_hex(c) when c in 0..9, do: ?0 + c
-  defp to_hex(c) when c in 10..15, do: ?A + c - 10
-
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
-end

lib/elixir/lib/code/typespec.ex

@@ -1,430 +0,0 @@
-defmodule Code.Typespec do
-  @moduledoc false
-
-  @doc """
-  Converts a spec clause back to Elixir quoted expression.
-  """
-  @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]}
-  def spec_to_quoted(name, spec)
-
-  def spec_to_quoted(name, {:type, line, :fun, [{:type, _, :product, args}, result]})
-      when is_atom(name) do
-    meta = [line: line]
-    body = {name, meta, Enum.map(args, &typespec_to_quoted/1)}
-
-    vars =
-      for type_expr <- args ++ [result],
-          var <- collect_vars(type_expr),
-          uniq: true,
-          do: {var, {:var, meta, nil}}
-
-    spec = {:::, meta, [body, typespec_to_quoted(result)]}
-
-    if vars == [] do
-      spec
-    else
-      {:when, meta, [spec, vars]}
-    end
-  end
-
-  def spec_to_quoted(name, {:type, line, :fun, []}) when is_atom(name) do
-    {:::, [line: line], [{name, [line: line], []}, quote(do: term)]}
-  end
-
-  def spec_to_quoted(name, {:type, line, :bounded_fun, [type, constrs]}) when is_atom(name) do
-    {:type, _, :fun, [{:type, _, :product, args}, result]} = type
-
-    guards =
-      for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do
-        {erl_to_ex_var(var), typespec_to_quoted(type)}
-      end
-
-    meta = [line: line]
-    ignore_vars = Keyword.keys(guards)
-
-    vars =
-      for type_expr <- args ++ [result],
-          var <- collect_vars(type_expr),
-          var not in ignore_vars,
-          uniq: true,
-          do: {var, {:var, meta, nil}}
-
-    args = for arg <- args, do: typespec_to_quoted(arg)
-
-    when_args = [
-      {:::, meta, [{name, [line: line], args}, typespec_to_quoted(result)]},
-      guards ++ vars
-    ]
-
-    {:when, meta, when_args}
-  end
-
-  @doc """
-  Converts a type clause back to Elixir AST.
-  """
-  def type_to_quoted(type)
-
-  def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do
-    fields = for field <- fields, do: typespec_to_quoted(field)
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    type = {:{}, [], [record | fields]}
-    quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type))
-  end
-
-  def type_to_quoted({name, type, args}) when is_atom(name) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type)))
-  end
-
-  @doc """
-  Returns all types available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is the type (`:typep`, `:type` and `:opaque`).
-
-  The module must have a corresponding BEAM file which can be
-  located by the runtime system. The types will be in the Erlang
-  Abstract Format.
-  """
-  @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error
-  def fetch_types(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types
-        exported_types = List.flatten(exported_types)
-
-        types =
-          for {:attribute, _, kind, {name, _, args} = type} <- abstract_code,
-              kind in [:opaque, :type] do
-            cond do
-              kind == :opaque -> {:opaque, type}
-              {name, length(args)} in exported_types -> {:type, type}
-              true -> {:typep, type}
-            end
-          end
-
-        {:ok, types}
-
-      _ ->
-        :error
-    end
-  end
-
-  @doc """
-  Returns all specs available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module must have a corresponding BEAM file which can be
-  located by the runtime system. The types will be in the Erlang
-  Abstract Format.
-  """
-  @spec fetch_specs(module) :: {:ok, [tuple]} | :error
-  def fetch_specs(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)}
-
-      :error ->
-        :error
-    end
-  end
-
-  @doc """
-  Returns all callbacks available from the module's BEAM code.
-
-  The result is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module must have a corresponding BEAM file
-  which can be located by the runtime system. The types will be
-  in the Erlang Abstract Format.
-  """
-  @spec fetch_callbacks(module) :: {:ok, [tuple]} | :error
-  def fetch_callbacks(module) when is_atom(module) or is_binary(module) do
-    case typespecs_abstract_code(module) do
-      {:ok, abstract_code} ->
-        {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)}
-
-      :error ->
-        :error
-    end
-  end
-
-  # TODO: Do not rely on abstract_code when OTP 20+ support is dropped (v1.8).
-  # We should then be able to simplify this code and use `with`.
-  defp typespecs_abstract_code(module) do
-    case get_module_and_beam(module) do
-      {module, binary} ->
-        case :beam_lib.chunks(binary, [:debug_info]) do
-          {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} ->
-            case data do
-              {:elixir_v1, %{}, specs} ->
-                # Fast path to avoid translation to Erlang from Elixir.
-                {:ok, specs}
-
-              _ ->
-                case backend.debug_info(:erlang_v1, module, data, []) do
-                  {:ok, abstract_code} -> {:ok, abstract_code}
-                  _ -> :error
-                end
-            end
-
-          _ ->
-            case :beam_lib.chunks(binary, [:abstract_code]) do
-              {:ok, {_, [{:abstract_code, {_raw_abstract_v1, abstract_code}}]}} ->
-                {:ok, abstract_code}
-
-              _ ->
-                :error
-            end
-        end
-
-      :error ->
-        :error
-    end
-  end
-
-  defp get_module_and_beam(module) when is_atom(module) do
-    case :code.get_object_code(module) do
-      {^module, beam, _filename} -> {module, beam}
-      :error -> :error
-    end
-  end
-
-  defp get_module_and_beam(beam) when is_binary(beam) do
-    case :beam_lib.info(beam) do
-      [_ | _] = info -> {info[:module], beam}
-      _ -> :error
-    end
-  end
-
-  ## To AST conversion
-
-  defp collect_vars({:ann_type, _line, args}) when is_list(args) do
-    []
-  end
-
-  defp collect_vars({:type, _line, _kind, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:remote_type, _line, args}) when is_list(args) do
-    Enum.flat_map(args, &collect_vars/1)
-  end
-
-  defp collect_vars({:typed_record_field, _line, type}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:paren_type, _line, [type]}) do
-    collect_vars(type)
-  end
-
-  defp collect_vars({:var, _line, var}) do
-    [erl_to_ex_var(var)]
-  end
-
-  defp collect_vars(_) do
-    []
-  end
-
-  defp typespec_to_quoted({:user_type, line, name, args}) do
-    typespec_to_quoted({:type, line, name, args})
-  end
-
-  defp typespec_to_quoted({:type, line, :tuple, :any}) do
-    {:tuple, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, line, :tuple, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {:{}, [line: line], args}
-  end
-
-  defp typespec_to_quoted({:type, _line, :list, [{:type, _, :union, unions} = arg]}) do
-    case unpack_typespec_kw(unions, []) do
-      {:ok, ast} -> ast
-      :error -> [typespec_to_quoted(arg)]
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :list, []}) do
-    {:list, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, _line, :list, [arg]}) do
-    [typespec_to_quoted(arg)]
-  end
-
-  defp typespec_to_quoted({:type, line, :nonempty_list, []}) do
-    [{:..., [line: line], nil}]
-  end
-
-  defp typespec_to_quoted({:type, line, :nonempty_list, [arg]}) do
-    [typespec_to_quoted(arg), {:..., [line: line], nil}]
-  end
-
-  defp typespec_to_quoted({:type, line, :map, :any}) do
-    {:map, [line: line], []}
-  end
-
-  defp typespec_to_quoted({:type, line, :map, fields}) do
-    fields =
-      Enum.map(fields, fn
-        {:type, _, :map_field_assoc, :any} ->
-          {{:optional, [], [{:any, [], []}]}, {:any, [], []}}
-
-        {:type, _, :map_field_exact, [{:atom, _, k}, v]} ->
-          {k, typespec_to_quoted(v)}
-
-        {:type, _, :map_field_exact, [k, v]} ->
-          {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
-
-        {:type, _, :map_field_assoc, [k, v]} ->
-          {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)}
-      end)
-
-    {struct, fields} = Keyword.pop(fields, :__struct__)
-    map = {:%{}, [line: line], fields}
-
-    if struct do
-      {:%, [line: line], [struct, map]}
-    else
-      map
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :binary, [arg1, arg2]}) do
-    [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg)
-
-    case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do
-      {arg1, 0} ->
-        quote(line: line, do: <<_::unquote(arg1)>>)
-
-      {0, arg2} ->
-        quote(line: line, do: <<_::_*unquote(arg2)>>)
-
-      {arg1, arg2} ->
-        quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>)
-    end
-  end
-
-  defp typespec_to_quoted({:type, line, :union, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, [line: line], [arg, expr]} end)
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, [{:type, _, :product, args}, result]}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    [{:->, [line: line], [args, typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, [args, result]}) do
-    [{:->, [line: line], [[typespec_to_quoted(args)], typespec_to_quoted(result)]}]
-  end
-
-  defp typespec_to_quoted({:type, line, :fun, []}) do
-    typespec_to_quoted({:type, line, :fun, [{:type, line, :any}, {:type, line, :any, []}]})
-  end
-
-  defp typespec_to_quoted({:type, line, :range, [left, right]}) do
-    {:.., [line: line], [typespec_to_quoted(left), typespec_to_quoted(right)]}
-  end
-
-  defp typespec_to_quoted({:type, _line, nil, []}) do
-    []
-  end
-
-  defp typespec_to_quoted({:type, line, name, args}) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    {name, [line: line], args}
-  end
-
-  defp typespec_to_quoted({:var, line, var}) do
-    {erl_to_ex_var(var), line, nil}
-  end
-
-  defp typespec_to_quoted({:op, line, op, arg}) do
-    {op, [line: line], [typespec_to_quoted(arg)]}
-  end
-
-  defp typespec_to_quoted({:remote_type, line, [mod, name, args]}) do
-    remote_type(line, mod, name, args)
-  end
-
-  defp typespec_to_quoted({:ann_type, line, [var, type]}) do
-    {:::, [line: line], [typespec_to_quoted(var), typespec_to_quoted(type)]}
-  end
-
-  defp typespec_to_quoted(
-         {:typed_record_field, {:record_field, line, {:atom, line1, name}}, type}
-       ) do
-    typespec_to_quoted({:ann_type, line, [{:var, line1, name}, type]})
-  end
-
-  defp typespec_to_quoted({:type, _, :any}) do
-    quote(do: ...)
-  end
-
-  defp typespec_to_quoted({:paren_type, _, [type]}) do
-    typespec_to_quoted(type)
-  end
-
-  defp typespec_to_quoted({type, _line, atom}) when is_atom(type) do
-    atom
-  end
-
-  defp typespec_to_quoted(other), do: other
-
-  ## Helpers
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do
-    typespec_to_quoted({:type, line, :charlist, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do
-    typespec_to_quoted({:type, line, :nonempty_charlist, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :struct}, []) do
-    typespec_to_quoted({:type, line, :struct, []})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do
-    typespec_to_quoted({:type, line, :as_boolean, [arg]})
-  end
-
-  defp remote_type(line, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do
-    typespec_to_quoted({:type, line, :keyword, args})
-  end
-
-  defp remote_type(line, mod, name, args) do
-    args = for arg <- args, do: typespec_to_quoted(arg)
-    dot = {:., [line: line], [typespec_to_quoted(mod), typespec_to_quoted(name)]}
-    {dot, [line: line], args}
-  end
-
-  defp erl_to_ex_var(var) do
-    case Atom.to_string(var) do
-      <<"_", c::utf8, rest::binary>> ->
-        String.to_atom("_#{String.downcase(<<c::utf8>>)}#{rest}")
-
-      <<c::utf8, rest::binary>> ->
-        String.to_atom("#{String.downcase(<<c::utf8>>)}#{rest}")
-    end
-  end
-
-  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do
-    unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc])
-  end
-
-  defp unpack_typespec_kw([], acc) do
-    {:ok, Enum.reverse(acc)}
-  end
-
-  defp unpack_typespec_kw(_, _acc) do
-    :error
-  end
-end

lib/elixir/lib/collectable.ex

@@ -24,54 +24,23 @@ defprotocol Collectable do
   `Enumerable` protocol. `into/1` can be seen as the opposite of
   `Enumerable.reduce/3`. If `Enumerable` is about taking values out,
   `Collectable.into/1` is about collecting those values into a structure.
-
-  ## Examples
-
-  To show how to manually use the `Collectable` protocol, let's play with its
-  implementation for `MapSet`.
-
-      iex> {initial_acc, collector_fun} = Collectable.into(MapSet.new())
-      iex> updated_acc = Enum.reduce([1, 2, 3], initial_acc, fn elem, acc ->
-      ...>   collector_fun.(acc, {:cont, elem})
-      ...> end)
-      iex> collector_fun.(updated_acc, :done)
-      #MapSet<[1, 2, 3]>
-
-  To show how the protocol can be implemented, we can take again a look at the
-  implementation for `MapSet`. In this implementation "collecting" elements
-  simply means inserting them in the set through `MapSet.put/2`.
-
-      defimpl Collectable do
-        def into(original) do
-          collector_fun = fn
-            set, {:cont, elem} -> MapSet.put(set, elem)
-            set, :done -> set
-            _set, :halt -> :ok
-          end
-
-          {original, collector_fun}
-        end
-      end
-
   """
 
   @type command :: {:cont, term} | :done | :halt
 
   @doc """
-  Returns an initial accumulator and a "collector" function.
+  Returns a function that collects values alongside
+  the initial accumulation value.
 
-  The returned function receives a term and a command and injects the term into
-  the collectable on every `{:cont, term}` command.
+  The returned function receives a collectable and injects a given
+  value into it for every `{:cont, term}` instruction.
 
-  `:done` is passed as a command when no further values will be injected. This
-  is useful when there's a need to close resources or normalizing values. A
-  collectable must be returned when the command is `:done`.
+  `:done` is passed when no further values will be injected, useful
+  for closing resources and normalizing values. A collectable must
+  be returned on `:done`.
 
-  If injection is suddenly interrupted, `:halt` is passed and the function
-  can return any value as it won't be used.
-
-  For examples on how to use the `Collectable` protocol and `into/1` see the
-  module documentation.
+  If injection is suddenly interrupted, `:halt` is passed and it can
+  return any value, as it won't be used.
   """
   @spec into(t) :: {term, (term, command -> t | term)}
   def into(collectable)
@@ -79,65 +48,30 @@ end
 
 defimpl Collectable, for: List do
   def into(original) do
-    fun = fn
+    {[], fn
       list, {:cont, x} -> [x | list]
       list, :done -> original ++ :lists.reverse(list)
       _, :halt -> :ok
-    end
-
-    {[], fun}
+    end}
   end
 end
 
 defimpl Collectable, for: BitString do
-  def into(original) when is_binary(original) do
-    fun = fn
-      acc, {:cont, x} when is_binary(x) and is_list(acc) ->
-        [acc | x]
-
-      acc, {:cont, x} when is_bitstring(x) and is_bitstring(acc) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<IO.iodata_to_binary(acc)::bitstring, x::bitstring>>
-
-      acc, :done when is_bitstring(acc) ->
-        acc
-
-      acc, :done ->
-        IO.iodata_to_binary(acc)
-
-      _, :halt ->
-        :ok
-    end
-
-    {[original], fun}
-  end
-
-  def into(original) when is_bitstring(original) do
-    fun = fn
-      acc, {:cont, x} when is_bitstring(x) ->
-        <<acc::bitstring, x::bitstring>>
-
-      acc, :done ->
-        acc
-
-      _, :halt ->
-        :ok
-    end
-
-    {original, fun}
+  def into(original) do
+    {original, fn
+      acc, {:cont, x} when is_bitstring(x) -> [acc | x]
+      acc, :done -> IO.iodata_to_binary(acc)
+      _, :halt -> :ok
+    end}
   end
 end
 
 defimpl Collectable, for: Map do
   def into(original) do
-    fun = fn
+    {original, fn
       map, {:cont, {k, v}} -> :maps.put(k, v, map)
       map, :done -> map
       _, :halt -> :ok
-    end
-
-    {original, fun}
+    end}
   end
 end

lib/elixir/lib/dict.ex

@@ -1,6 +1,6 @@
 defmodule Dict do
   @moduledoc ~S"""
-  Generic API for dictionaries.
+  WARNING: this module is deprecated.
 
   If you need a general dictionary, use the `Map` module.
   If you need to manipulate keyword lists, use `Keyword`.
@@ -9,26 +9,19 @@ defmodule Dict do
   `new` function in the respective modules.
   """
 
-  @moduledoc deprecated: "Use Map or Keyword modules instead"
-
   @type key :: any
   @type value :: any
   @type t :: list | map
 
-  message =
-    "Use the Map module for working with maps or the Keyword module for working with keyword lists"
-
-  # TODO: Remove by 2.0
-
-  @deprecated message
+  # TODO: Deprecate every function by 1.4
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
-    quote do
-      message = "Use maps and the Map module instead"
+    %{file: file, line: line} = __CALLER__
+    :elixir_errors.warn(line, file, "the Dict module is deprecated")
 
-      @deprecated message
+    quote do
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -36,7 +29,6 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def get_lazy(dict, key, fun) when is_function(fun, 0) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -44,14 +36,12 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def get_and_update(dict, key, fun) do
         current_value = get(dict, key)
         {get, new_value} = fun.(current_value)
         {get, put(dict, key, new_value)}
       end
 
-      @deprecated message
       def fetch!(dict, key) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -59,35 +49,30 @@ defmodule Dict do
         end
       end
 
-      @deprecated message
       def has_key?(dict, key) do
-        match?({:ok, _}, fetch(dict, key))
+        match? {:ok, _}, fetch(dict, key)
       end
 
-      @deprecated message
       def put_new(dict, key, value) do
         case has_key?(dict, key) do
-          true -> dict
+          true  -> dict
           false -> put(dict, key, value)
         end
       end
 
-      @deprecated message
       def put_new_lazy(dict, key, fun) when is_function(fun, 0) do
         case has_key?(dict, key) do
-          true -> dict
+          true  -> dict
           false -> put(dict, key, fun.())
         end
       end
 
-      @deprecated message
       def drop(dict, keys) do
         Enum.reduce(keys, dict, &delete(&2, &1))
       end
 
-      @deprecated message
       def take(dict, keys) do
-        Enum.reduce(keys, new(), fn key, acc ->
+        Enum.reduce(keys, new, fn key, acc ->
           case fetch(dict, key) do
             {:ok, value} -> put(acc, key, value)
             :error -> acc
@@ -95,49 +80,41 @@ defmodule Dict do
         end)
       end
 
-      @deprecated message
       def to_list(dict) do
-        reduce(dict, {:cont, []}, fn kv, acc -> {:cont, [kv | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          kv, acc -> {:cont, [kv | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def keys(dict) do
-        reduce(dict, {:cont, []}, fn {k, _}, acc -> {:cont, [k | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          {k, _}, acc -> {:cont, [k | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def values(dict) do
-        reduce(dict, {:cont, []}, fn {_, v}, acc -> {:cont, [v | acc]} end)
-        |> elem(1)
-        |> :lists.reverse()
+        reduce(dict, {:cont, []}, fn
+          {_, v}, acc -> {:cont, [v | acc]}
+        end) |> elem(1) |> :lists.reverse
       end
 
-      @deprecated message
       def equal?(dict1, dict2) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
         case size(dict1) == size(dict2) do
-          false ->
-            false
-
-          true ->
-            reduce(dict1, {:cont, true}, fn {k, v}, _acc ->
+          false -> false
+          true  ->
+            reduce(dict1, {:cont, true}, fn({k, v}, _acc) ->
               case fetch(dict2, k) do
                 {:ok, ^v} -> {:cont, true}
                 _ -> {:halt, false}
               end
-            end)
-            |> elem(1)
+            end) |> elem(1)
         end
       end
 
-      @deprecated message
-      def merge(dict1, dict2, fun \\ fn _k, _v1, v2 -> v2 end) do
+      def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
         # Use this import to avoid conflicts in the user code
         import Kernel, except: [size: 1]
 
@@ -149,182 +126,144 @@ defmodule Dict do
           reduce(dict2, {:cont, dict1}, fn {k, v2}, acc ->
             {:cont, update(acc, k, v2, &fun.(k, &1, v2))}
           end)
-        end
-        |> elem(1)
+        end |> elem(1)
       end
 
-      @deprecated message
       def update(dict, key, initial, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
-
           :error ->
             put(dict, key, initial)
         end
       end
 
-      @deprecated message
       def update!(dict, key, fun) do
         case fetch(dict, key) do
           {:ok, value} ->
             put(dict, key, fun.(value))
-
           :error ->
             raise KeyError, key: key, term: dict
         end
       end
 
-      @deprecated message
       def pop(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} ->
             {value, delete(dict, key)}
-
           :error ->
             {default, dict}
         end
       end
 
-      @deprecated message
       def pop_lazy(dict, key, fun) when is_function(fun, 0) do
         case fetch(dict, key) do
           {:ok, value} ->
             {value, delete(dict, key)}
-
           :error ->
             {fun.(), dict}
         end
       end
 
-      @deprecated message
       def split(dict, keys) do
-        Enum.reduce(keys, {new(), dict}, fn key, {inc, exc} = acc ->
+        Enum.reduce(keys, {new, dict}, fn key, {inc, exc} = acc ->
           case fetch(exc, key) do
             {:ok, value} ->
               {put(inc, key, value), delete(exc, key)}
-
             :error ->
               acc
           end
         end)
       end
 
-      defoverridable merge: 2,
-                     merge: 3,
-                     equal?: 2,
-                     to_list: 1,
-                     keys: 1,
-                     values: 1,
-                     take: 2,
-                     drop: 2,
-                     get: 2,
-                     get: 3,
-                     fetch!: 2,
-                     has_key?: 2,
-                     put_new: 3,
-                     pop: 2,
-                     pop: 3,
-                     split: 2,
-                     update: 4,
-                     update!: 3,
-                     get_and_update: 3,
-                     get_lazy: 3,
-                     pop_lazy: 3,
-                     put_new_lazy: 3
+      defoverridable merge: 2, merge: 3, equal?: 2, to_list: 1, keys: 1,
+                     values: 1, take: 2, drop: 2, get: 2, get: 3, fetch!: 2,
+                     has_key?: 2, put_new: 3, pop: 2, pop: 3, split: 2,
+                     update: 4, update!: 3, get_and_update: 3, get_lazy: 3,
+                     pop_lazy: 3, put_new_lazy: 3
     end
   end
 
   defmacrop target(dict) do
     quote do
       case unquote(dict) do
-        %module{} -> module
-        %{} -> Map
-        dict when is_list(dict) -> Keyword
-        dict -> unsupported_dict(dict)
+        %{__struct__: x} when is_atom(x) ->
+          x
+        %{} ->
+          Map
+        x when is_list(x) ->
+          Keyword
+        x ->
+          unsupported_dict(x)
       end
     end
   end
 
-  @deprecated message
   @spec keys(t) :: [key]
   def keys(dict) do
     target(dict).keys(dict)
   end
 
-  @deprecated message
   @spec values(t) :: [value]
   def values(dict) do
     target(dict).values(dict)
   end
 
-  @deprecated message
   @spec size(t) :: non_neg_integer
   def size(dict) do
     target(dict).size(dict)
   end
 
-  @deprecated message
   @spec has_key?(t, key) :: boolean
   def has_key?(dict, key) do
     target(dict).has_key?(dict, key)
   end
 
-  @deprecated message
   @spec get(t, key, value) :: value
   def get(dict, key, default \\ nil) do
     target(dict).get(dict, key, default)
   end
 
-  @deprecated message
   @spec get_lazy(t, key, (() -> value)) :: value
   def get_lazy(dict, key, fun) do
     target(dict).get_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}
   def get_and_update(dict, key, fun) do
     target(dict).get_and_update(dict, key, fun)
   end
 
-  @deprecated message
   @spec fetch(t, key) :: value
   def fetch(dict, key) do
     target(dict).fetch(dict, key)
   end
 
-  @deprecated message
   @spec fetch!(t, key) :: value | no_return
   def fetch!(dict, key) do
     target(dict).fetch!(dict, key)
   end
 
-  @deprecated message
   @spec put(t, key, value) :: t
   def put(dict, key, val) do
     target(dict).put(dict, key, val)
   end
 
-  @deprecated message
   @spec put_new(t, key, value) :: t
   def put_new(dict, key, val) do
     target(dict).put_new(dict, key, val)
   end
 
-  @deprecated message
   @spec put_new_lazy(t, key, (() -> value)) :: t
   def put_new_lazy(dict, key, fun) do
     target(dict).put_new_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec delete(t, key) :: t
   def delete(dict, key) do
     target(dict).delete(dict, key)
   end
 
-  @deprecated message
   @spec merge(t, t) :: t
   def merge(dict1, dict2) do
     target1 = target(dict1)
@@ -333,11 +272,10 @@ defmodule Dict do
     if target1 == target2 do
       target1.merge(dict1, dict2)
     else
-      do_merge(target1, dict1, dict2, fn _k, _v1, v2 -> v2 end)
+      do_merge(target1, dict1, dict2, fn(_k, _v1, v2) -> v2 end)
     end
   end
 
-  @deprecated message
   @spec merge(t, t, (key, value, value -> value)) :: t
   def merge(dict1, dict2, fun) do
     target1 = target(dict1)
@@ -351,61 +289,51 @@ defmodule Dict do
   end
 
   defp do_merge(target1, dict1, dict2, fun) do
-    Enumerable.reduce(dict2, {:cont, dict1}, fn {k, v}, acc ->
-      {:cont, target1.update(acc, k, v, fn other -> fun.(k, other, v) end)}
-    end)
-    |> elem(1)
+    Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
+      {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
+    end) |> elem(1)
   end
 
-  @deprecated message
   @spec pop(t, key, value) :: {value, t}
   def pop(dict, key, default \\ nil) do
     target(dict).pop(dict, key, default)
   end
 
-  @deprecated message
   @spec pop_lazy(t, key, (() -> value)) :: {value, t}
   def pop_lazy(dict, key, fun) do
     target(dict).pop_lazy(dict, key, fun)
   end
 
-  @deprecated message
   @spec update!(t, key, (value -> value)) :: t
   def update!(dict, key, fun) do
     target(dict).update!(dict, key, fun)
   end
 
-  @deprecated message
   @spec update(t, key, value, (value -> value)) :: t
   def update(dict, key, initial, fun) do
     target(dict).update(dict, key, initial, fun)
   end
 
-  @deprecated message
   @spec split(t, [key]) :: {t, t}
   def split(dict, keys) do
     target(dict).split(dict, keys)
   end
 
-  @deprecated message
   @spec drop(t, [key]) :: t
   def drop(dict, keys) do
     target(dict).drop(dict, keys)
   end
 
-  @deprecated message
   @spec take(t, [key]) :: t
   def take(dict, keys) do
     target(dict).take(dict, keys)
   end
 
-  @deprecated message
   @spec empty(t) :: t
   def empty(dict) do
     target(dict).empty(dict)
   end
 
-  @deprecated message
   @spec equal?(t, t) :: boolean
   def equal?(dict1, dict2) do
     target1 = target(dict1)
@@ -416,20 +344,18 @@ defmodule Dict do
         target1.equal?(dict1, dict2)
 
       target1.size(dict1) == target2.size(dict2) ->
-        Enumerable.reduce(dict2, {:cont, true}, fn {k, v}, _acc ->
+        Enumerable.reduce(dict2, {:cont, true}, fn({k, v}, _acc) ->
           case target1.fetch(dict1, k) do
             {:ok, ^v} -> {:cont, true}
-            _ -> {:halt, false}
+            _         -> {:halt, false}
           end
-        end)
-        |> elem(1)
+        end) |> elem(1)
 
       true ->
         false
     end
   end
 
-  @deprecated message
   @spec to_list(t) :: list
   def to_list(dict) do
     target(dict).to_list(dict)
@@ -437,6 +363,6 @@ defmodule Dict do
 
   @spec unsupported_dict(t) :: no_return
   defp unsupported_dict(dict) do
-    raise ArgumentError, "unsupported dict: #{inspect(dict)}"
+    raise ArgumentError, "unsupported dict: #{inspect dict}"
   end
 end

lib/elixir/lib/file/stat.ex

@@ -53,9 +53,9 @@ defmodule File.Stat do
   """
 
   record = Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-  keys = :lists.map(&elem(&1, 0), record)
-  vals = :lists.map(&{&1, [], nil}, keys)
-  pairs = :lists.zip(keys, vals)
+  keys   = :lists.map(&elem(&1, 0), record)
+  vals   = :lists.map(&{&1, [], nil}, keys)
+  pairs  = :lists.zip(keys, vals)
 
   defstruct keys
   @type t :: %__MODULE__{}
@@ -71,7 +71,6 @@ defmodule File.Stat do
   Converts a `:file_info` record into a `File.Stat`.
   """
   def from_record(file_info)
-
   def from_record({:file_info, unquote_splicing(vals)}) do
     %File.Stat{unquote_splicing(pairs)}
   end

lib/elixir/lib/file/stream.ex

@@ -7,7 +7,7 @@ defmodule File.Stream do
     * `path`          - the file path
     * `modes`         - the file modes
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given number of bytes
+    * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
   """
 
@@ -22,12 +22,11 @@ defmodule File.Stream do
     modes =
       case raw do
         true ->
-          case :lists.keyfind(:read_ahead, 1, modes) do
-            {:read_ahead, false} -> [:raw | :lists.keydelete(:read_ahead, 1, modes)]
-            {:read_ahead, _} -> [:raw | modes]
-            false -> [:raw, :read_ahead | modes]
+          if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
+            [:raw | modes]
+          else
+            [:raw, :read_ahead | modes]
           end
-
         false ->
           modes
       end
@@ -37,12 +36,11 @@ defmodule File.Stream do
 
   defimpl Collectable do
     def into(%{path: path, modes: modes, raw: raw} = stream) do
-      modes = for mode <- modes, mode not in [:read], do: mode
+      modes = for mode <- modes, not mode in [:read], do: mode
 
       case :file.open(path, [:write | modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
-
         {:error, reason} ->
           raise File.Error, reason: reason, action: "stream", path: path
       end
@@ -52,16 +50,14 @@ defmodule File.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true -> IO.binwrite(device, x)
+            true  -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
-
         :ok, :done ->
           # If delayed_write option is used and the last write failed will
           # MatchError here as {:error, _} is returned.
           :ok = :file.close(device)
           stream
-
         :ok, :halt ->
           # If delayed_write option is used and the last write failed will
           # MatchError here as {:error, _} is returned.
@@ -71,55 +67,27 @@ defmodule File.Stream do
   end
 
   defimpl Enumerable do
-    @read_ahead_size 64 * 1024
-
     def reduce(%{path: path, modes: modes, line_or_bytes: line_or_bytes, raw: raw}, acc, fun) do
-      start_fun = fn ->
-        case :file.open(path, read_modes(modes)) do
-          {:ok, device} ->
-            if :trim_bom in modes, do: trim_bom(device, raw) |> elem(0), else: device
+      modes = for mode <- modes, not mode in [:write, :append], do: mode
 
-          {:error, reason} ->
-            raise File.Error, reason: reason, action: "stream", path: path
+      start_fun =
+        fn ->
+          case :file.open(path, modes) do
+            {:ok, device}    -> device
+            {:error, reason} ->
+              raise File.Error, reason: reason, action: "stream", path: path
+          end
         end
-      end
 
       next_fun =
         case raw do
-          true -> &IO.each_binstream(&1, line_or_bytes)
+          true  -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
 
       Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)
     end
 
-    def count(%{path: path, modes: modes, line_or_bytes: :line} = stream) do
-      pattern = :binary.compile_pattern("\n")
-      counter = &count_lines(&1, path, pattern, read_function(stream), 0)
-
-      case File.open(path, read_modes(modes), counter) do
-        {:ok, count} ->
-          {:ok, count}
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    def count(%{path: path, line_or_bytes: bytes, raw: true, modes: modes}) do
-      case File.stat(path) do
-        {:ok, %{size: 0}} ->
-          {:error, __MODULE__}
-
-        {:ok, %{size: size}} ->
-          remainder = if rem(size, bytes) == 0, do: 0, else: 1
-          {:ok, div(size, bytes) + remainder - count_raw_bom(path, modes)}
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
     def count(_stream) do
       {:error, __MODULE__}
     end
@@ -127,64 +95,5 @@ defmodule File.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    def slice(_stream) do
-      {:error, __MODULE__}
-    end
-
-    defp count_raw_bom(path, modes) do
-      if :trim_bom in modes do
-        File.open!(path, read_modes(modes), &(&1 |> trim_bom(true) |> elem(1)))
-      else
-        0
-      end
-    end
-
-    defp trim_bom(device, true) do
-      bom_length = device |> IO.binread(4) |> bom_length()
-      {:ok, new_pos} = :file.position(device, bom_length)
-      {device, new_pos}
-    end
-
-    defp trim_bom(device, false) do
-      # Or we read the bom in the correct amount or it isn't there
-      case bom_length(IO.read(device, 1)) do
-        0 ->
-          {:ok, _} = :file.position(device, 0)
-          {device, 0}
-
-        _ ->
-          {device, 1}
-      end
-    end
-
-    defp bom_length(<<239, 187, 191, _rest::binary>>), do: 3
-    defp bom_length(<<254, 255, _rest::binary>>), do: 2
-    defp bom_length(<<255, 254, _rest::binary>>), do: 2
-    defp bom_length(<<0, 0, 254, 255, _rest::binary>>), do: 4
-    defp bom_length(<<254, 255, 0, 0, _rest::binary>>), do: 4
-    defp bom_length(_binary), do: 0
-
-    defp read_modes(modes) do
-      for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode
-    end
-
-    defp count_lines(device, path, pattern, read, count) do
-      case read.(device) do
-        data when is_binary(data) ->
-          count_lines(device, path, pattern, read, count + count_lines(data, pattern))
-
-        :eof ->
-          count
-
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    defp count_lines(data, pattern), do: length(:binary.matches(data, pattern))
-
-    defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)
-    defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)
   end
 end

lib/elixir/lib/float.ex

@@ -2,50 +2,9 @@ import Kernel, except: [round: 1]
 
 defmodule Float do
   @moduledoc """
-  Functions for working with floating-point numbers.
-
-  ## Kernel functions
-
-  There are functions related to floating-point numbers on the `Kernel` module
-  too. Here is a list of them:
-
-    * `Kernel.round/1`: rounds a number to the nearest integer.
-    * `Kernel.trunc/1`: returns the integer part of a number.
-
-  ## Known issues
-
-  There are some very well known problems with floating-point numbers
-  and arithmetics due to the fact most decimal fractions cannot be
-  represented by a floating-point binary and most operations are not exact,
-  but operate on approximations. Those issues are not specific
-  to Elixir, they are a property of floating point representation itself.
-
-  For example, the numbers 0.1 and 0.01 are two of them, what means the result
-  of squaring 0.1 does not give 0.01 neither the closest representable. Here is
-  what happens in this case:
-
-    * The closest representable number to 0.1 is 0.1000000014
-    * The closest representable number to 0.01 is 0.0099999997
-    * Doing 0.1 * 0.1 should return 0.01, but because 0.1 is actually 0.1000000014,
-      the result is 0.010000000000000002, and because this is not the closest
-      representable number to 0.01, you'll get the wrong result for this operation
-
-  There are also other known problems like flooring or rounding numbers. See
-  `round/2` and `floor/2` for more details about them.
-
-  To learn more about floating-point arithmetic visit:
-
-    * [0.30000000000000004.com](http://0.30000000000000004.com/)
-    * [What Every Programmer Should Know About Floating-Point Arithmetic](http://floating-point-gui.de/)
-
+  Functions for working with floating point numbers.
   """
 
-  import Bitwise
-
-  @power_of_2_to_52 4_503_599_627_370_496
-  @precision_range 0..15
-  @type precision_range :: 0..15
-
   @doc """
   Parses a binary into a float.
 
@@ -63,8 +22,10 @@ defmodule Float do
 
       iex> Float.parse("34")
       {34.0, ""}
+
       iex> Float.parse("34.25")
       {34.25, ""}
+
       iex> Float.parse("56.5xyz")
       {56.5, "xyz"}
 
@@ -88,94 +49,66 @@ defmodule Float do
     parse_unsigned(binary)
   end
 
-  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9,
-    do: parse_unsigned(rest, false, false, <<digit>>)
+  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9, do:
+    parse_unsigned(rest, false, false, <<digit>>)
 
-  defp parse_unsigned(binary) when is_binary(binary), do: :error
+  defp parse_unsigned(binary) when is_binary(binary), do:
+    :error
 
-  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9,
-    do: parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
+  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9, do:
+    parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
 
-  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9,
-    do: parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
+  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9, do:
+    parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
 
-  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc)
-       when exp_marker in 'eE' and digit in ?0..?9,
-       do: parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
+  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and  digit in ?0..?9, do:
+    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
 
-  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc)
-       when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9,
-       do: parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
+  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9, do:
+    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
 
-  defp parse_unsigned(rest, dot?, _e?, acc),
-    do: {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
+  defp parse_unsigned(rest, dot?, _e?, acc), do:
+    {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
 
-  defp add_dot(acc, true), do: acc
+  defp add_dot(acc, true),  do: acc
   defp add_dot(acc, false), do: acc <> ".0"
 
   @doc """
-  Rounds a float to the largest number less than or equal to `num`.
+  Rounds a float to the largest integer less than or equal to `num`.
 
-  `floor/2` also accepts a precision to round a floating-point value down
+  `floor/2` also accepts a precision to round a floating point value down
   to an arbitrary number of fractional digits (between 0 and 15).
-  The operation is performed on the binary floating point, without a
-  conversion to decimal.
 
   This function always returns a float. `Kernel.trunc/1` may be used instead to
   truncate the result to an integer afterwards.
 
-  ## Known issues
-
-  The behaviour of `floor/2` for floats can be surprising. For example:
-
-      iex> Float.floor(12.52, 2)
-      12.51
-
-  One may have expected it to floor to 12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 12.51999999,
-  which explains the behaviour above.
-
   ## Examples
 
       iex> Float.floor(34.25)
       34.0
+
       iex> Float.floor(-56.5)
       -57.0
+
       iex> Float.floor(34.259, 2)
       34.25
 
   """
-  @spec floor(float, precision_range) :: float
-  def floor(number, precision \\ 0)
-
-  def floor(number, precision) when is_float(number) and precision in @precision_range do
-    round(number, precision, :floor)
-  end
-
-  def floor(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
+  @spec floor(float, 0..15) :: float
+  def floor(number, precision \\ 0) when is_float(number) and precision in 0..15 do
+    power     = power_of_10(precision)
+    number    = number * power
+    truncated = trunc(number)
+    variance  = if number - truncated < 0, do: -1.0, else: 0.0
+    (truncated + variance) / power
   end
 
   @doc """
   Rounds a float to the smallest integer greater than or equal to `num`.
 
-  `ceil/2` also accepts a precision to round a floating-point value down
+  `ceil/2` also accepts a precision to round a floating point value down
   to an arbitrary number of fractional digits (between 0 and 15).
 
-  The operation is performed on the binary floating point, without a
-  conversion to decimal.
-
-  The behaviour of `ceil/2` for floats can be surprising. For example:
-
-      iex> Float.ceil(-12.52, 2)
-      -12.51
-
-  One may have expected it to ceil to -12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as -12.51999999,
-  which explains the behaviour above.
-
   This function always returns floats. `Kernel.trunc/1` may be used instead to
   truncate the result to an integer afterwards.
 
@@ -183,256 +116,60 @@ defmodule Float do
 
       iex> Float.ceil(34.25)
       35.0
+
       iex> Float.ceil(-56.5)
       -56.0
+
       iex> Float.ceil(34.251, 2)
       34.26
 
   """
-  @spec ceil(float, precision_range) :: float
-  def ceil(number, precision \\ 0)
-
-  def ceil(number, precision) when is_float(number) and precision in @precision_range do
-    round(number, precision, :ceil)
-  end
-
-  def ceil(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
+  @spec ceil(float, 0..15) :: float
+  def ceil(number, precision \\ 0) when is_float(number) and precision in 0..15 do
+    power     = power_of_10(precision)
+    number    = number * power
+    truncated = trunc(number)
+    variance  = if number - truncated > 0, do: 1.0, else: 0.0
+    (truncated + variance) / power
   end
 
   @doc """
-  Rounds a floating-point value to an arbitrary number of fractional
-  digits (between 0 and 15).
-
-  The rounding direction always ties to half up. The operation is
-  performed on the binary floating point, without a conversion to decimal.
+  Rounds a floating point value to an arbitrary number of fractional digits
+  (between 0 and 15).
 
   This function only accepts floats and always returns a float. Use
-  `Kernel.round/1` if you want a function that accepts both floats
-  and integers and always returns an integer.
-
-  ## Known issues
-
-  The behaviour of `round/2` for floats can be surprising. For example:
-
-      iex> Float.round(5.5675, 3)
-      5.567
-
-  One may have expected it to round to the half up 5.568. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 5.567499999,
-  which explains the behaviour above. If you want exact rounding for decimals,
-  you must use a decimal library. The behaviour above is also in accordance
-  to reference implementations, such as "Correctly Rounded Binary-Decimal and
-  Decimal-Binary Conversions" by David M. Gay.
+  `Kernel.round/1` if you want a function that accepts both floats and integers
+  and always returns an integer.
 
   ## Examples
 
-      iex> Float.round(12.5)
-      13.0
       iex> Float.round(5.5674, 3)
       5.567
+
       iex> Float.round(5.5675, 3)
-      5.567
+      5.568
+
       iex> Float.round(-5.5674, 3)
       -5.567
+
+      iex> Float.round(-5.5675, 3)
+      -5.568
+
       iex> Float.round(-5.5675)
       -6.0
-      iex> Float.round(12.341444444444441, 15)
-      12.341444444444441
 
   """
-  @spec round(float, precision_range) :: float
-  # This implementation is slow since it relies on big integers.
-  # Faster implementations are available on more recent papers
-  # and could be implemented in the future.
-  def round(float, precision \\ 0)
-
-  def round(float, precision) when is_float(float) and precision in @precision_range do
-    round(float, precision, :half_up)
+  @spec round(float, 0..15) :: float
+  def round(number, precision \\ 0) when is_float(number) and precision in 0..15 do
+    power = power_of_10(precision)
+    Kernel.round(number * power) / power
   end
 
-  def round(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  defp round(float, precision, rounding) do
-    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
-    {num, count, _} = decompose(significant)
-    count = count - exp + 1023
-
-    cond do
-      # There is no decimal precision
-      # zero or minus zero
-      count <= 0 or (0 == exp and <<0::52>> == significant) ->
-        float
-
-      # Precision beyond 15 digits
-      count >= 104 ->
-        case rounding do
-          :ceil when sign === 0 -> 1 / power_of_10(precision)
-          :floor when sign === 1 -> -1 / power_of_10(precision)
-          _ -> 0.0
-        end
-
-      # We are asking more precision than we have
-      count <= precision ->
-        float
-
-      true ->
-        # Difference in precision between float and asked precision
-        # We subtract 1 because we need to calculate the remainder too
-        diff = count - precision - 1
-
-        # Get up to latest so we calculate the remainder
-        power_of_10 = power_of_10(diff)
-
-        # Convert the numerand to decimal base
-        num = num * power_of_5(count)
-
-        # Move to the given precision - 1
-        num = div(num, power_of_10)
-        div = div(num, 10)
-        num = rounding(rounding, sign, num, div)
-
-        # Convert back to float without loss
-        # http://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/
-        den = power_of_10(precision)
-        boundary = den <<< 52
-
-        cond do
-          num == 0 ->
-            0.0
-
-          num >= boundary ->
-            {den, exp} = scale_down(num, boundary, 52)
-            decimal_to_float(sign, num, den, exp)
-
-          true ->
-            {num, exp} = scale_up(num, boundary, 52)
-            decimal_to_float(sign, num, den, exp)
-        end
-    end
-  end
-
-  defp scale_up(num, boundary, exp) when num >= boundary, do: {num, exp}
-  defp scale_up(num, boundary, exp), do: scale_up(num <<< 1, boundary, exp - 1)
-
-  defp scale_down(num, den, exp) do
-    new_den = den <<< 1
-
-    if num < new_den do
-      {den >>> 52, exp}
-    else
-      scale_down(num, new_den, exp + 1)
-    end
-  end
-
-  defp decimal_to_float(sign, num, den, exp) do
-    quo = div(num, den)
-    rem = num - quo * den
-
-    tmp =
-      case den >>> 1 do
-        den when rem > den -> quo + 1
-        den when rem < den -> quo
-        _ when (quo &&& 1) === 1 -> quo + 1
-        _ -> quo
-      end
-
-    tmp = tmp - @power_of_2_to_52
-    <<tmp::float>> = <<sign::1, exp + 1023::11, tmp::52>>
-    tmp
-  end
-
-  defp rounding(:floor, 1, _num, div), do: div + 1
-  defp rounding(:ceil, 0, _num, div), do: div + 1
-
-  defp rounding(:half_up, _sign, num, div) do
-    case rem(num, 10) do
-      rem when rem < 5 -> div
-      rem when rem >= 5 -> div + 1
-    end
-  end
-
-  defp rounding(_, _, _, div), do: div
-
-  Enum.reduce(0..104, 1, fn x, acc ->
+  Enum.reduce 0..15, 1, fn x, acc ->
     defp power_of_10(unquote(x)), do: unquote(acc)
     acc * 10
-  end)
-
-  Enum.reduce(0..104, 1, fn x, acc ->
-    defp power_of_5(unquote(x)), do: unquote(acc)
-    acc * 5
-  end)
-
-  @doc """
-  Returns a pair of integers whose ratio is exactly equal
-  to the original float and with a positive denominator.
-
-  ## Examples
-
-      iex> Float.ratio(3.14)
-      {7070651414971679, 2251799813685248}
-      iex> Float.ratio(-3.14)
-      {-7070651414971679, 2251799813685248}
-      iex> Float.ratio(1.5)
-      {3, 2}
-      iex> Float.ratio(-1.5)
-      {-3, 2}
-      iex> Float.ratio(16.0)
-      {16, 1}
-      iex> Float.ratio(-16.0)
-      {-16, 1}
-
-  """
-  @doc since: "1.4.0"
-  @spec ratio(float) :: {pos_integer | neg_integer, pos_integer}
-  def ratio(float) when is_float(float) do
-    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
-    {num, _, den} = decompose(significant)
-    num = sign(sign, num)
-
-    case exp - 1023 do
-      exp when exp > 0 ->
-        {den, exp} = shift_right(den, exp)
-        {shift_left(num, exp), den}
-
-      exp when exp < 0 ->
-        {num, shift_left(den, -exp)}
-
-      0 ->
-        {num, den}
-    end
   end
 
-  defp decompose(significant) do
-    decompose(significant, 1, 0, 2, 1, 1)
-  end
-
-  defp decompose(<<1::1, bits::bitstring>>, count, last_count, power, _last_power, acc) do
-    decompose(bits, count + 1, count, power <<< 1, power, shift_left(acc, count - last_count) + 1)
-  end
-
-  defp decompose(<<0::1, bits::bitstring>>, count, last_count, power, last_power, acc) do
-    decompose(bits, count + 1, last_count, power <<< 1, last_power, acc)
-  end
-
-  defp decompose(<<>>, _count, last_count, _power, last_power, acc) do
-    {acc, last_count, last_power}
-  end
-
-  defp sign(0, num), do: num
-  defp sign(1, num), do: -num
-
-  defp shift_left(num, 0), do: num
-  defp shift_left(num, times), do: shift_left(num <<< 1, times - 1)
-
-  defp shift_right(num, 0), do: {num, 0}
-  defp shift_right(1, times), do: {1, times}
-  defp shift_right(num, times), do: shift_right(num >>> 1, times - 1)
-
   @doc """
   Returns a charlist which corresponds to the text representation
   of the given float.
@@ -468,36 +205,29 @@ defmodule Float do
       "7.0"
 
   """
-  @spec to_string(float) :: String.t()
+  @spec to_string(float) :: String.t
   def to_string(float) when is_float(float) do
     IO.iodata_to_binary(:io_lib_format.fwrite_g(float))
   end
 
+  # TODO: Deprecate by v1.5
   @doc false
-  # TODO: Remove by 2.0
-  @deprecated "Use Float.to_charlist/1 instead"
   def to_char_list(float), do: Float.to_charlist(float)
 
+  # TODO: Deprecate by v1.4
   @doc false
-  # TODO: Remove by 2.0
-  @deprecated "Use :erlang.float_to_list/2 instead"
   def to_char_list(float, options) do
     :erlang.float_to_list(float, expand_compact(options))
   end
 
+  # TODO: Deprecate by v1.4
   @doc false
-  # TODO: Remove by 2.0
-  @deprecated "Use :erlang.float_to_binary/2 instead"
   def to_string(float, options) do
     :erlang.float_to_binary(float, expand_compact(options))
   end
 
-  defp invalid_precision_message(precision) do
-    "precision #{precision} is out of valid range of #{inspect(@precision_range)}"
-  end
-
   defp expand_compact([{:compact, false} | t]), do: expand_compact(t)
-  defp expand_compact([{:compact, true} | t]), do: [:compact | expand_compact(t)]
-  defp expand_compact([h | t]), do: [h | expand_compact(t)]
-  defp expand_compact([]), do: []
+  defp expand_compact([{:compact, true} | t]),  do: [:compact | expand_compact(t)]
+  defp expand_compact([h | t]),                 do: [h | expand_compact(t)]
+  defp expand_compact([]),                      do: []
 end

lib/elixir/lib/function.ex

@@ -1,137 +0,0 @@
-defmodule Function do
-  @moduledoc """
-  A set of functions for working with functions.
-
-  There are two types of captured functions: **external** and **local**.
-  External functions are functions residing in modules that are captured
-  with `&/1`, such as `&String.length/1`. Local functions are anonymous functions
-  defined with `fn/1` or with the capture operator `&/1` using `&1`, `&2`,
-  and so on as replacements.
-  """
-
-  @type information ::
-          :arity
-          | :env
-          | :index
-          | :module
-          | :name
-          | :new_index
-          | :new_uniq
-          | :pid
-          | :type
-          | :uniq
-
-  @doc """
-  Captures the given function.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Function.capture(String, :length, 1)
-      &String.length/1
-
-  """
-  @doc since: "1.7.0"
-  @spec capture(module, atom, arity) :: fun
-  def capture(module, function_name, arity) do
-    :erlang.make_fun(module, function_name, arity)
-  end
-
-  @doc """
-  Returns a keyword list with information about a function.
-
-  The returned keys (with the corresponding possible values) for
-  all types of functions (local and external) are the following:
-
-    * `:type` - `:local` (for anonymous functions) or `:external` (for
-      named functions).
-
-    * `:module` - an atom which is the module where the function is defined when
-    anonymous or the module which the function refers to when it's a named function.
-
-    * `:arity` - (integer) the number of arguments the function is to be called with.
-
-    * `:name` - (atom) the name of the function.
-
-    * `:env` - a list of the environment or free variables. For named
-      functions, the returned list is always empty.
-
-  When `fun` is an anonymous function (that is, the type is `:local`), the following
-  additional keys are returned:
-
-    * `:pid` - PID of the process that originally created the function.
-
-    * `:index` - (integer) an index into the module function table.
-
-    * `:new_index` - (integer) an index into the module function table.
-
-    * `:new_uniq` - (binary) a unique value for this function. It's
-      calculated from the compiled code for the entire module.
-
-    * `:uniq` - (integer) a unique value for this function. This integer is
-      calculated from the compiled code for the entire module.
-
-  **Note**: this function must be used only for debugging purposes.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> fun = fn x -> x end
-      iex> info = Function.info(fun)
-      iex> Keyword.get(info, :arity)
-      1
-      iex> Keyword.get(info, :type)
-      :local
-
-      iex> fun = &String.length/1
-      iex> info = Function.info(fun)
-      iex> Keyword.get(info, :type)
-      :external
-      iex> Keyword.get(info, :name)
-      :length
-
-  """
-  @doc since: "1.7.0"
-  @spec info(fun) :: [{information, term}]
-  def info(fun), do: :erlang.fun_info(fun)
-
-  @doc """
-  Returns a specific information about the function.
-
-  The returned information is a two-element tuple in the shape of
-  `{info, value}`.
-
-  For any function, the information asked for can be any of the atoms
-  `:module`, `:name`, `:arity`, `:env`, or `:type`.
-
-  For anonymous functions, there is also information about any of the
-  atoms `:index`, `:new_index`, `:new_uniq`, `:uniq`, and `:pid`.
-  For a named function, the value of any of these items is always the
-  atom `:undefined`.
-
-  For more information on each of the possible returned values, see
-  `info/1`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> f = fn x -> x end
-      iex> Function.info(f, :arity)
-      {:arity, 1}
-      iex> Function.info(f, :type)
-      {:type, :local}
-
-      iex> fun = &String.length/1
-      iex> Function.info(fun, :name)
-      {:name, :length}
-      iex> Function.info(fun, :pid)
-      {:pid, :undefined}
-
-  """
-  @doc since: "1.7.0"
-  @spec info(fun, item) :: {item, term} when item: information
-  def info(fun, item), do: :erlang.fun_info(fun, item)
-end

lib/elixir/lib/gen_event/stream.ex

@@ -1,8 +1,19 @@
 defmodule GenEvent.Stream do
-  @moduledoc false
+  @moduledoc """
+  Defines a `GenEvent` stream.
+
+  This is a struct returned by `GenEvent.stream/2`. The struct is public and
+  contains the following fields:
+
+    * `:manager`  - the manager reference given to `GenEvent.stream/2`
+    * `:timeout`  - the timeout between events, defaults to `:infinity`
+
+  """
   defstruct manager: nil, timeout: :infinity
 
-  @type t :: %__MODULE__{manager: GenEvent.manager(), timeout: timeout}
+  @type t :: %__MODULE__{
+               manager: GenEvent.manager,
+               timeout: timeout}
 
   @doc false
   def init({_pid, _ref} = state) do
@@ -22,7 +33,6 @@ defmodule GenEvent.Stream do
   def handle_call(msg, _state) do
     # We do this to trick Dialyzer to not complain about non-local returns.
     reason = {:bad_call, msg}
-
     case :erlang.phash2(1, 1) do
       0 -> exit(reason)
       1 -> {:remove_handler, reason}
@@ -47,7 +57,7 @@ end
 
 defimpl Enumerable, for: GenEvent.Stream do
   def reduce(stream, acc, fun) do
-    start_fun = fn -> start(stream) end
+    start_fun = fn() -> start(stream) end
     next_fun = &next(stream, &1)
     stop_fun = &stop(stream, &1)
     Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))
@@ -61,33 +71,26 @@ defimpl Enumerable, for: GenEvent.Stream do
     {:error, __MODULE__}
   end
 
-  def slice(_stream) do
-    {:error, __MODULE__}
-  end
-
   defp wrap_reducer(fun) do
     fn
       {:ack, manager, ref, event}, acc ->
-        send(manager, {ref, :ok})
+        send manager, {ref, :ok}
         fun.(event, acc)
-
       {:async, _manager, _ref, event}, acc ->
         fun.(event, acc)
-
       {:sync, manager, ref, event}, acc ->
         try do
           fun.(event, acc)
         after
-          send(manager, {ref, :ok})
+          send manager, {ref, :ok}
         end
     end
   end
 
   defp start(%{manager: manager} = stream) do
     try do
-      {:ok, {pid, ref}} =
-        :gen.call(manager, self(), {:add_process_handler, self(), self()}, :infinity)
-
+      {:ok, {pid, ref}} = :gen.call(manager, self(),
+                                    {:add_process_handler, self(), self()}, :infinity)
       mon_ref = Process.monitor(pid)
       {pid, ref, mon_ref}
     catch
@@ -135,7 +138,6 @@ defimpl Enumerable, for: GenEvent.Stream do
     case wait_for_handler_removal(pid, ref, mon_ref) do
       :ok ->
         flush_events(ref)
-
       {:error, reason} ->
         exit({reason, {__MODULE__, :stop, [stream, acc]}})
     end
@@ -144,7 +146,7 @@ defimpl Enumerable, for: GenEvent.Stream do
   # If we reach this branch, the handler was not removed yet,
   # so we trigger a request for doing so.
   defp stop(stream, {pid, ref, _} = acc) do
-    _ = :gen_event.delete_handler(pid, {pid, ref}, :shutdown)
+    _ = GenEvent.remove_handler(pid, {pid, ref}, :shutdown)
     stop(stream, {:removed, acc})
   end
 
@@ -153,7 +155,6 @@ defimpl Enumerable, for: GenEvent.Stream do
       {:gen_event_EXIT, {^pid, ^ref}, _reason} ->
         Process.demonitor(mon_ref, [:flush])
         :ok
-
       {:DOWN, ^mon_ref, _, _, reason} ->
         {:error, reason}
     end
@@ -161,8 +162,7 @@ defimpl Enumerable, for: GenEvent.Stream do
 
   defp flush_events(ref) do
     receive do
-      {_from, {_pid, ^ref}, {notify, _event}}
-      when notify in [:notify, :ack_notify, :sync_notify] ->
+      {_from, {_pid, ^ref}, {notify, _event}} when notify in [:notify, :ack_notify, :sync_notify] ->
         flush_events(ref)
     after
       0 -> :ok

lib/elixir/lib/hash_dict.ex

@@ -1,13 +1,11 @@
 defmodule HashDict do
   @moduledoc """
-  Tuple-based HashDict implementation.
+  WARNING: this module is deprecated.
 
-  This module is deprecated. Use the `Map` module instead.
+  Use the `Map` module instead.
   """
 
-  @moduledoc deprecated: "Use Map instead"
-
-  # TODO: Remove by 2.0
+  # TODO: Deprecate every function by 1.4
 
   use Dict
 
@@ -24,70 +22,58 @@ defmodule HashDict do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
-  message = "Use maps and the Map module instead"
-
   @doc """
   Creates a new empty dict.
   """
-  @spec new :: Dict.t()
-  @deprecated message
+  @spec new :: Dict.t
   def new do
     %HashDict{}
   end
 
-  @deprecated message
   def put(%HashDict{root: root, size: size}, key, value) do
     {root, counter} = do_put(root, key, value, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def update!(%HashDict{root: root, size: size} = dict, key, fun) when is_function(fun, 1) do
-    {root, counter} =
-      do_update(root, key, fn -> raise KeyError, key: key, term: dict end, fun, key_hash(key))
-
+    {root, counter} = do_update(root, key, fn -> raise KeyError, key: key, term: dict end,
+                                fun, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def update(%HashDict{root: root, size: size}, key, initial, fun) when is_function(fun, 1) do
     {root, counter} = do_update(root, key, fn -> initial end, fun, key_hash(key))
     %HashDict{root: root, size: size + counter}
   end
 
-  @deprecated message
   def fetch(%HashDict{root: root}, key) do
     do_fetch(root, key, key_hash(key))
   end
 
-  @deprecated message
   def delete(dict, key) do
     case dict_delete(dict, key) do
       {dict, _value} -> dict
-      :error -> dict
+      :error         -> dict
     end
   end
 
-  @deprecated message
   def pop(dict, key, default \\ nil) do
     case dict_delete(dict, key) do
       {dict, value} -> {value, dict}
-      :error -> {default, dict}
+      :error        -> {default, dict}
     end
   end
 
-  @deprecated message
   def size(%HashDict{size: size}) do
     size
   end
 
   @doc false
-  @deprecated message
   def reduce(%HashDict{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc} -> {:halted, acc}
-      {:cont, acc} -> {:done, acc}
+      {:halt, acc}    -> {:halted, acc}
+      {:cont, acc}    -> {:done, acc}
     end)
   end
 
@@ -97,7 +83,7 @@ defmodule HashDict do
   def dict_delete(%HashDict{root: root, size: size}, key) do
     case do_delete(root, key, key_hash(key)) do
       {root, value} -> {%HashDict{root: root, size: size - 1}, value}
-      :error -> :error
+      :error        -> :error
     end
   end
 
@@ -105,32 +91,26 @@ defmodule HashDict do
 
   defp do_fetch(node, key, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
-      [^key | v] -> {:ok, v}
+      [^key | v]   -> {:ok, v}
       {^key, v, _} -> {:ok, v}
-      {_, _, n} -> do_fetch(n, key, key_shift(hash))
-      _ -> :error
+      {_, _, n}    -> do_fetch(n, key, key_shift(hash))
+      _            -> :error
     end
   end
 
   defp do_put(node, key, value, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [key | value]), 1}
-
       [^key | _] ->
         {put_elem(node, index, [key | value]), 0}
-
       [k | v] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])
         {put_elem(node, index, {k, v, n}), 1}
-
       {^key, _, n} ->
         {put_elem(node, index, {key, value, n}), 0}
-
       {k, v, n} ->
         {n, counter} = do_put(n, key, value, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
@@ -139,21 +119,16 @@ defmodule HashDict do
 
   defp do_update(node, key, initial, fun, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [key | initial.()]), 1}
-
       [^key | value] ->
         {put_elem(node, index, [key | fun.(value)]), 0}
-
       [k | v] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [key | initial.()])
         {put_elem(node, index, {k, v, n}), 1}
-
       {^key, value, n} ->
         {put_elem(node, index, {key, fun.(value), n}), 0}
-
       {k, v, n} ->
         {n, counter} = do_update(n, key, initial, fun, key_shift(hash))
         {put_elem(node, index, {k, v, n}), counter}
@@ -162,35 +137,28 @@ defmodule HashDict do
 
   defp do_delete(node, key, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         :error
-
       [^key | value] ->
         {put_elem(node, index, []), value}
-
       [_ | _] ->
         :error
-
       {^key, value, n} ->
         {put_elem(node, index, do_compact_node(n)), value}
-
       {k, v, n} ->
         case do_delete(n, key, key_shift(hash)) do
           {@node_template, value} ->
             {put_elem(node, index, [k | v]), value}
-
           {n, value} ->
             {put_elem(node, index, {k, v, n}), value}
-
           :error ->
             :error
         end
     end
   end
 
-  Enum.each(0..(@node_size - 1), fn index ->
+  Enum.each 0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
         [k | v] ->
@@ -198,12 +166,11 @@ defmodule HashDict do
             @node_template -> [k | v]
             n -> {k, v, n}
           end
-
         {k, v, n} ->
           {k, v, put_elem(node, unquote(index), do_compact_node(n))}
       end
     end
-  end)
+  end
 
   ## Dict reduce
 
@@ -228,12 +195,7 @@ defmodule HashDict do
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(
-      :erlang.element(count, node),
-      acc,
-      fun,
-      &do_reduce(node, &1, fun, count - 1, next)
-    )
+    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -258,45 +220,19 @@ defmodule HashDict do
 end
 
 defimpl Enumerable, for: HashDict do
-  def reduce(dict, acc, fun) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    module.reduce(dict, acc, fun)
-  end
-
-  def member?(dict, {key, value}) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, match?({:ok, ^value}, module.fetch(dict, key))}
-  end
-
-  def member?(_dict, _) do
-    {:ok, false}
-  end
-
-  def count(dict) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, module.size(dict)}
-  end
-
-  def slice(_dict) do
-    {:error, __MODULE__}
-  end
+  def reduce(dict, acc, fun),  do: HashDict.reduce(dict, acc, fun)
+  def member?(dict, {k, v}), do: {:ok, match?({:ok, ^v}, HashDict.fetch(dict, k))}
+  def member?(_dict, _),       do: {:ok, false}
+  def count(dict),             do: {:ok, HashDict.size(dict)}
 end
 
 defimpl Collectable, for: HashDict do
   def into(original) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-
-    collector_fun = fn
-      dict, {:cont, {key, value}} -> module.put(dict, key, value)
+    {original, fn
+      dict, {:cont, {k, v}} -> HashDict.put(dict, k, v)
       dict, :done -> dict
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -304,8 +240,6 @@ defimpl Inspect, for: HashDict do
   import Inspect.Algebra
 
   def inspect(dict, opts) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    concat(["#HashDict<", Inspect.List.inspect(module.to_list(dict), opts), ">"])
+    concat ["#HashDict<", Inspect.List.inspect(HashDict.to_list(dict), opts), ">"]
   end
 end

lib/elixir/lib/hash_set.ex

@@ -1,19 +1,17 @@
 defmodule HashSet do
   @moduledoc """
-  Tuple-based HashSet implementation.
+  WARNING: this module is deprecated.
 
-  This module is deprecated. Use the `MapSet` module instead.
+  Use the `MapSet` module instead.
   """
 
-  @moduledoc deprecated: "Use MapSet instead"
+  # TODO: Deprecate every function by 1.4
 
   @node_bitmap 0b111
   @node_shift 3
   @node_size 8
   @node_template :erlang.make_tuple(@node_size, [])
 
-  message = "Use the MapSet module instead"
-
   @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
   @doc false
   defstruct size: 0, root: @node_template
@@ -22,85 +20,71 @@ defmodule HashSet do
   @compile :inline_list_funcs
   @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
 
-  @deprecated message
-  @spec new :: Set.t()
+  @spec new :: Set.t
   def new do
     %HashSet{}
   end
 
-  @deprecated message
   def union(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) when size1 <= size2 do
-    set_fold(set1, set2, fn v, acc -> put(acc, v) end)
+    set_fold set1, set2, fn v, acc -> put(acc, v) end
   end
 
-  @deprecated message
   def union(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set2, set1, fn v, acc -> put(acc, v) end)
+    set_fold set2, set1, fn v, acc -> put(acc, v) end
   end
 
-  @deprecated message
   def intersection(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set1, %HashSet{}, fn v, acc ->
+    set_fold set1, %HashSet{}, fn v, acc ->
       if member?(set2, v), do: put(acc, v), else: acc
-    end)
-  end
-
-  @deprecated message
-  def difference(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold(set2, set1, fn v, acc -> delete(acc, v) end)
-  end
-
-  @deprecated message
-  def to_list(set) do
-    set_fold(set, [], &[&1 | &2]) |> :lists.reverse()
-  end
-
-  @deprecated message
-  def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
-    case size1 do
-      ^size2 -> subset?(set1, set2)
-      _ -> false
     end
   end
 
-  @deprecated message
+  def difference(%HashSet{} = set1, %HashSet{} = set2) do
+    set_fold set2, set1, fn v, acc -> delete(acc, v) end
+  end
+
+  def to_list(set) do
+    set_fold(set, [], &[&1 | &2]) |> :lists.reverse
+  end
+
+  def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
+    case size1 do
+      ^size2 -> subset?(set1, set2)
+      _      -> false
+    end
+  end
+
   def subset?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set1, {:cont, true}, fn member, acc ->
       case member?(set2, member) do
         true -> {:cont, acc}
-        _ -> {:halt, false}
+        _    -> {:halt, false}
       end
-    end)
-    |> elem(1)
+    end) |> elem(1)
   end
 
-  @deprecated message
   def disjoint?(%HashSet{} = set1, %HashSet{} = set2) do
     reduce(set2, {:cont, true}, fn member, acc ->
       case member?(set1, member) do
         false -> {:cont, acc}
-        _ -> {:halt, false}
+        _     -> {:halt, false}
       end
-    end)
-    |> elem(1)
+    end) |> elem(1)
   end
 
-  @deprecated message
   def member?(%HashSet{root: root}, term) do
     do_member?(root, term, key_hash(term))
   end
 
-  @deprecated message
   def put(%HashSet{root: root, size: size}, term) do
     {root, counter} = do_put(root, term, key_hash(term))
     %HashSet{root: root, size: size + counter}
   end
 
-  @deprecated message
   def delete(%HashSet{root: root, size: size} = set, term) do
     case do_delete(root, term, key_hash(term)) do
       {:ok, root} -> %HashSet{root: root, size: size - 1}
-      :error -> set
+      :error      -> set
     end
   end
 
@@ -108,12 +92,11 @@ defmodule HashSet do
   def reduce(%HashSet{root: root}, acc, fun) do
     do_reduce(root, acc, fun, @node_size, fn
       {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc} -> {:halted, acc}
-      {:cont, acc} -> {:done, acc}
+      {:halt, acc}    -> {:halted, acc}
+      {:cont, acc}    -> {:done, acc}
     end)
   end
 
-  @deprecated message
   def size(%HashSet{size: size}) do
     size
   end
@@ -128,29 +111,24 @@ defmodule HashSet do
 
   defp do_member?(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
-      [] -> false
+      []          -> false
       [^term | _] -> true
-      [_] -> false
-      [_ | n] -> do_member?(n, term, key_shift(hash))
+      [_]         -> false
+      [_ | n]     -> do_member?(n, term, key_shift(hash))
     end
   end
 
   defp do_put(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [term]), 1}
-
       [^term | _] ->
         {node, 0}
-
       [t] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
         {put_elem(node, index, [t | n]), 1}
-
       [t | n] ->
         {n, counter} = do_put(n, term, key_shift(hash))
         {put_elem(node, index, [t | n]), counter}
@@ -159,35 +137,28 @@ defmodule HashSet do
 
   defp do_delete(node, term, hash) do
     index = key_mask(hash)
-
     case elem(node, index) do
       [] ->
         :error
-
       [^term] ->
         {:ok, put_elem(node, index, [])}
-
       [_] ->
         :error
-
       [^term | n] ->
         {:ok, put_elem(node, index, do_compact_node(n))}
-
       [t | n] ->
         case do_delete(n, term, key_shift(hash)) do
           {:ok, @node_template} ->
             {:ok, put_elem(node, index, [t])}
-
           {:ok, n} ->
             {:ok, put_elem(node, index, [t | n])}
-
           :error ->
             :error
         end
     end
   end
 
-  Enum.each(0..(@node_size - 1), fn index ->
+  Enum.each 0..(@node_size - 1), fn index ->
     defp do_compact_node(node) when elem(node, unquote(index)) != [] do
       case elem(node, unquote(index)) do
         [t] ->
@@ -195,17 +166,16 @@ defmodule HashSet do
             @node_template -> [t]
             n -> [t | n]
           end
-
         [t | n] ->
           [t | put_elem(node, unquote(index), do_compact_node(n))]
       end
     end
-  end)
+  end
 
   ## Set fold
 
-  defp do_fold_each([], acc, _fun), do: acc
-  defp do_fold_each([t], acc, fun), do: fun.(t, acc)
+  defp do_fold_each([], acc, _fun),     do: acc
+  defp do_fold_each([t], acc, fun),     do: fun.(t, acc)
   defp do_fold_each([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
 
   defp do_fold(node, acc, fun, count) when count > 0 do
@@ -240,12 +210,7 @@ defmodule HashSet do
   end
 
   defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(
-      :erlang.element(count, node),
-      acc,
-      fun,
-      &do_reduce(node, &1, fun, count - 1, next)
-    )
+    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
   end
 
   defp do_reduce(_node, acc, _fun, 0, next) do
@@ -270,41 +235,18 @@ defmodule HashSet do
 end
 
 defimpl Enumerable, for: HashSet do
-  def reduce(set, acc, fun) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    module.reduce(set, acc, fun)
-  end
-
-  def member?(set, term) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.member?(set, term)}
-  end
-
-  def count(set) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.size(set)}
-  end
-
-  def slice(_set) do
-    {:error, __MODULE__}
-  end
+  def reduce(set, acc, fun), do: HashSet.reduce(set, acc, fun)
+  def member?(set, v),       do: {:ok, HashSet.member?(set, v)}
+  def count(set),            do: {:ok, HashSet.size(set)}
 end
 
 defimpl Collectable, for: HashSet do
   def into(original) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-
-    collector_fun = fn
-      set, {:cont, term} -> module.put(set, term)
+    {original, fn
+      set, {:cont, x} -> HashSet.put(set, x)
       set, :done -> set
       _, :halt -> :ok
-    end
-
-    {original, collector_fun}
+    end}
   end
 end
 
@@ -312,8 +254,6 @@ defimpl Inspect, for: HashSet do
   import Inspect.Algebra
 
   def inspect(set, opts) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    concat(["#HashSet<", Inspect.List.inspect(module.to_list(set), opts), ">"])
+    concat ["#HashSet<", Inspect.List.inspect(HashSet.to_list(set), opts), ">"]
   end
 end

lib/elixir/lib/inspect.ex

@@ -1,21 +1,17 @@
 import Kernel, except: [inspect: 1]
 import Inspect.Algebra
 
-alias Code.Identifier
-
 defprotocol Inspect do
   @moduledoc """
-  The `Inspect` protocol converts an Elixir data structure into an
-  algebra document.
-
-  This documentation refers to implementing the `Inspect` protocol
-  for your own data structures. To learn more about using inspect,
-  see `Kernel.inspect/2` and `IO.inspect/2`.
+  The `Inspect` protocol is responsible for converting any Elixir
+  data structure into an algebra document. This document is then
+  formatted, either in pretty printing format or a regular one.
 
   The `inspect/2` function receives the entity to be inspected
   followed by the inspecting options, represented by the struct
-  `Inspect.Opts`. Building of the algebra document is done with
-  `Inspect.Algebra`.
+  `Inspect.Opts`.
+
+  Inspection is done using the functions available in `Inspect.Algebra`.
 
   ## Examples
 
@@ -27,11 +23,11 @@ defprotocol Inspect do
         import Inspect.Algebra
 
         def inspect(dict, opts) do
-          concat(["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"])
+          concat ["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"]
         end
       end
 
-  The `concat/1` function comes from `Inspect.Algebra` and it
+  The `concat` function comes from `Inspect.Algebra` and it
   concatenates algebra documents together. In the example above,
   it is concatenating the string `"MapSet<"` (all strings are
   valid algebra documents that keep their formatting when pretty
@@ -52,7 +48,7 @@ defprotocol Inspect do
   implementation directly. For example, to test Inspect.MapSet above,
   you can invoke it as:
 
-      Inspect.MapSet.inspect(MapSet.new(), %Inspect.Opts{})
+      Inspect.MapSet.inspect(MapSet.new, %Inspect.Opts{})
 
   """
 
@@ -65,28 +61,89 @@ end
 defimpl Inspect, for: Atom do
   require Macro
 
-  def inspect(atom, opts) do
-    color(Identifier.inspect_as_atom(atom), color_key(atom), opts)
+  def inspect(atom, _opts) do
+    inspect(atom)
   end
 
-  defp color_key(atom) when is_boolean(atom), do: :boolean
-  defp color_key(nil), do: nil
-  defp color_key(_), do: :atom
+  def inspect(false),  do: "false"
+  def inspect(true),   do: "true"
+  def inspect(nil),    do: "nil"
+  def inspect(:""),    do: ":\"\""
+
+  def inspect(atom) do
+    binary = Atom.to_string(atom)
+
+    cond do
+      valid_ref_identifier?(binary) ->
+        if only_elixir?(binary) do
+          binary
+        else
+          "Elixir." <> rest = binary
+          rest
+        end
+      valid_atom_identifier?(binary) ->
+        ":" <> binary
+      atom in [:%{}, :{}, :<<>>, :..., :%] ->
+        ":" <> binary
+      atom in Macro.binary_ops or atom in Macro.unary_ops ->
+        ":" <> binary
+      true ->
+        <<?:, ?", Inspect.BitString.escape(binary, ?")::binary, ?">>
+    end
+  end
+
+  defp only_elixir?("Elixir." <> rest), do: only_elixir?(rest)
+  defp only_elixir?("Elixir"), do: true
+  defp only_elixir?(_), do: false
+
+  # Detect if atom is an atom alias (Elixir.Foo.Bar.Baz)
+
+  defp valid_ref_identifier?("Elixir" <> rest) do
+    valid_ref_piece?(rest)
+  end
+
+  defp valid_ref_identifier?(_), do: false
+
+  defp valid_ref_piece?(<<?., h, t::binary>>) when h in ?A..?Z do
+    valid_ref_piece? valid_identifier?(t)
+  end
+
+  defp valid_ref_piece?(<<>>), do: true
+  defp valid_ref_piece?(_),    do: false
+
+  # Detect if atom
+
+  defp valid_atom_identifier?(<<h, t::binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
+    valid_atom_piece?(t)
+  end
+
+  defp valid_atom_identifier?(_), do: false
+
+  defp valid_atom_piece?(t) do
+    case valid_identifier?(t) do
+      <<>>              -> true
+      <<??>>            -> true
+      <<?!>>            -> true
+      <<?@, t::binary>> -> valid_atom_piece?(t)
+      _                 -> false
+    end
+  end
+
+  defp valid_identifier?(<<h, t::binary>>)
+      when h in ?a..?z
+      when h in ?A..?Z
+      when h in ?0..?9
+      when h == ?_ do
+    valid_identifier? t
+  end
+
+  defp valid_identifier?(other), do: other
 end
 
 defimpl Inspect, for: BitString do
-  def inspect(term, opts) when is_binary(term) do
-    %Inspect.Opts{binaries: bins, base: base, printable_limit: printable_limit} = opts
-
-    if base == :decimal and
-         (bins == :as_strings or (bins == :infer and String.printable?(term, printable_limit))) do
-      inspected =
-        case Identifier.escape(term, ?", printable_limit) do
-          {escaped, ""} -> [?", escaped, ?"]
-          {escaped, _} -> [?", escaped, ?", " <> ..."]
-        end
-
-      color(IO.iodata_to_binary(inspected), :string, opts)
+  def inspect(term, %Inspect.Opts{binaries: bins, base: base} = opts) when is_binary(term) do
+    if base == :decimal and (bins == :as_strings or (bins == :infer and String.printable?(term))) do
+      <<?", escape(term, ?")::binary, ?">>
     else
       inspect_bitstring(term, opts)
     end
@@ -96,15 +153,100 @@ defimpl Inspect, for: BitString do
     inspect_bitstring(term, opts)
   end
 
-  defp inspect_bitstring("", opts) do
-    color("<<>>", :binary, opts)
+  ## Escaping
+
+  @doc false
+  def escape(other, char) do
+    escape(other, char, <<>>)
+  end
+
+  defp escape(<<char, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, char>>)
+  end
+  defp escape(<<?#, ?{, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?#, ?{>>)
+  end
+  defp escape(<<?\a, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?a>>)
+  end
+  defp escape(<<?\b, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?b>>)
+  end
+  defp escape(<<?\d, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?d>>)
+  end
+  defp escape(<<?\e, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?e>>)
+  end
+  defp escape(<<?\f, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?f>>)
+  end
+  defp escape(<<?\n, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?n>>)
+  end
+  defp escape(<<?\r, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?r>>)
+  end
+  defp escape(<<?\\, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?\\>>)
+  end
+  defp escape(<<?\t, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?t>>)
+  end
+  defp escape(<<?\v, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?v>>)
+  end
+  defp escape(<<h::utf8, t::binary>>, char, binary) do
+    head = <<h::utf8>>
+    if String.printable?(head) do
+      escape(t, char, append(head, binary))
+    else
+      <<byte::8, h::binary>> = head
+      t = <<h::binary, t::binary>>
+      escape(t, char, <<binary::binary, escape_char(byte)::binary>>)
+    end
+  end
+  defp escape(<<h, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, escape_char(h)::binary>>)
+  end
+  defp escape(<<>>, _char, binary), do: binary
+
+  @doc false
+  # Also used by Regex
+  def escape_char(0) do
+    <<?\\, ?0>>
+  end
+
+  def escape_char(char) when char < 0x100 do
+    <<a::4, b::4>> = <<char::8>>
+    <<?\\, ?x, to_hex(a), to_hex(b)>>
+  end
+
+  def escape_char(char) when char < 0x10000 do
+    <<a::4, b::4, c::4, d::4>> = <<char::16>>
+    <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}>>
+  end
+
+  def escape_char(char) when char < 0x1000000 do
+    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
+    <<?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c),
+                   to_hex(d), to_hex(e), to_hex(f), ?}>>
+  end
+
+  defp to_hex(c) when c in 0..9, do: ?0+c
+  defp to_hex(c) when c in 10..15, do: ?A+c-10
+
+  defp append(<<h, t::binary>>, binary), do: append(t, <<binary::binary, h>>)
+  defp append(<<>>, binary), do: binary
+
+  ## Bitstrings
+
+  defp inspect_bitstring("", _opts) do
+    "<<>>"
   end
 
   defp inspect_bitstring(bitstring, opts) do
-    left = color("<<", :binary, opts)
-    right = color(">>", :binary, opts)
-    inner = each_bit(bitstring, opts.limit, opts)
-    group(concat(concat(left, nest(inner, 2)), right))
+    nest surround("<<", each_bit(bitstring, opts.limit, opts), ">>"), 1
   end
 
   defp each_bit(_, 0, _) do
@@ -120,10 +262,8 @@ defimpl Inspect, for: BitString do
   end
 
   defp each_bit(<<h, t::bitstring>>, counter, opts) do
-    flex_glue(
-      concat(Inspect.Integer.inspect(h, opts), ","),
-      each_bit(t, decrement(counter), opts)
-    )
+    glue(concat(Inspect.Integer.inspect(h, opts), ","),
+         each_bit(t, decrement(counter), opts))
   end
 
   defp each_bit(bitstring, _counter, opts) do
@@ -132,70 +272,43 @@ defimpl Inspect, for: BitString do
     Inspect.Integer.inspect(h, opts) <> "::size(" <> Integer.to_string(size) <> ")"
   end
 
-  @compile {:inline, decrement: 1}
   defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
+  defp decrement(counter),   do: counter - 1
 end
 
 defimpl Inspect, for: List do
-  def inspect([], opts) do
-    color("[]", :list, opts)
-  end
-
-  # TODO: Remove :char_list and :as_char_lists handling in 2.0
-  def inspect(term, opts) do
-    %Inspect.Opts{
-      charlists: lists,
-      char_lists: lists_deprecated,
-      printable_limit: printable_limit
-    } = opts
+  def inspect([], _opts), do: "[]"
 
+  # TODO: Deprecate :char_lists and :as_char_lists keys in v1.5
+  def inspect(term, %Inspect.Opts{charlists: lists, char_lists: lists_deprecated} = opts) do
     lists =
       if lists == :infer and lists_deprecated != :infer do
         case lists_deprecated do
           :as_char_lists ->
-            IO.warn(
-              "the :char_lists inspect option and its :as_char_lists " <>
-                "value are deprecated, use the :charlists option and its " <>
-                ":as_charlists value instead"
-            )
-
             :as_charlists
-
           _ ->
-            IO.warn("the :char_lists inspect option is deprecated, use :charlists instead")
             lists_deprecated
         end
       else
         lists
       end
 
-    open = color("[", :list, opts)
-    sep = color(",", :list, opts)
-    close = color("]", :list, opts)
-
     cond do
-      lists == :as_charlists or (lists == :infer and List.ascii_printable?(term, printable_limit)) ->
-        inspected =
-          case Identifier.escape(IO.chardata_to_string(term), ?', printable_limit) do
-            {escaped, ""} -> [?', escaped, ?']
-            {escaped, _} -> [?', escaped, ?', " ++ ..."]
-          end
-
-        IO.iodata_to_binary(inspected)
-
+      lists == :as_charlists or (lists == :infer and printable?(term)) ->
+        <<?', Inspect.BitString.escape(IO.chardata_to_string(term), ?')::binary, ?'>>
       keyword?(term) ->
-        container_doc(open, term, close, opts, &keyword/2, separator: sep, break: :strict)
-
+        surround_many("[", term, "]", opts, &keyword/2)
       true ->
-        container_doc(open, term, close, opts, &to_doc/2, separator: sep)
+        surround_many("[", term, "]", opts, &to_doc/2)
     end
   end
 
   @doc false
   def keyword({key, value}, opts) do
-    key = color(Identifier.inspect_as_key(key), :atom, opts)
-    concat(key, concat(" ", to_doc(value, opts)))
+    concat(
+      key_to_binary(key) <> ": ",
+      to_doc(value, opts)
+    )
   end
 
   @doc false
@@ -206,131 +319,175 @@ defimpl Inspect, for: List do
     end
   end
 
-  def keyword?([]), do: true
+  def keyword?([]),     do: true
   def keyword?(_other), do: false
+
+  @doc false
+  def printable?([c | cs]) when c in 32..126, do: printable?(cs)
+  def printable?([?\n | cs]), do: printable?(cs)
+  def printable?([?\r | cs]), do: printable?(cs)
+  def printable?([?\t | cs]), do: printable?(cs)
+  def printable?([?\v | cs]), do: printable?(cs)
+  def printable?([?\b | cs]), do: printable?(cs)
+  def printable?([?\f | cs]), do: printable?(cs)
+  def printable?([?\e | cs]), do: printable?(cs)
+  def printable?([?\a | cs]), do: printable?(cs)
+  def printable?([]), do: true
+  def printable?(_), do: false
+
+  ## Private
+
+  defp key_to_binary(key) do
+    case Inspect.Atom.inspect(key) do
+      ":" <> right -> right
+      other -> other
+    end
+  end
 end
 
 defimpl Inspect, for: Tuple do
+  def inspect({}, _opts), do: "{}"
+
   def inspect(tuple, opts) do
-    open = color("{", :tuple, opts)
-    sep = color(",", :tuple, opts)
-    close = color("}", :tuple, opts)
-    container_opts = [separator: sep, break: :flex]
-    container_doc(open, Tuple.to_list(tuple), close, opts, &to_doc/2, container_opts)
+    surround_many("{", Tuple.to_list(tuple), "}", opts, &to_doc/2)
   end
 end
 
 defimpl Inspect, for: Map do
   def inspect(map, opts) do
-    inspect(map, "", opts)
+    nest inspect(map, "", opts), 1
   end
 
   def inspect(map, name, opts) do
     map = :maps.to_list(map)
-    open = color("%" <> name <> "{", :map, opts)
-    sep = color(",", :map, opts)
-    close = color("}", :map, opts)
-    container_doc(open, map, close, opts, traverse_fun(map, opts), separator: sep, break: :strict)
+    surround_many("%" <> name <> "{", map, "}", opts, traverse_fun(map))
   end
 
-  defp traverse_fun(list, opts) do
+  defp traverse_fun(list) do
     if Inspect.List.keyword?(list) do
       &Inspect.List.keyword/2
     else
-      sep = color(" => ", :map, opts)
-      &to_map(&1, &2, sep)
+      &to_map/2
     end
   end
 
-  defp to_map({key, value}, opts, sep) do
-    concat(concat(to_doc(key, opts), sep), to_doc(value, opts))
+  defp to_map({key, value}, opts) do
+    concat(
+      concat(to_doc(key, opts), " => "),
+      to_doc(value, opts)
+    )
   end
 end
 
 defimpl Inspect, for: Integer do
-  def inspect(term, %Inspect.Opts{base: base} = opts) do
-    inspected = Integer.to_string(term, base_to_value(base)) |> prepend_prefix(base)
-    color(inspected, :number, opts)
+  def inspect(term, %Inspect.Opts{base: base}) do
+    Integer.to_string(term, base_to_value(base))
+    |> prepend_prefix(base)
   end
 
   defp base_to_value(base) do
     case base do
-      :binary -> 2
+      :binary  -> 2
       :decimal -> 10
-      :octal -> 8
-      :hex -> 16
+      :octal   -> 8
+      :hex     -> 16
     end
   end
 
   defp prepend_prefix(value, :decimal), do: value
-
-  defp prepend_prefix(<<?-, value::binary>>, base) do
-    "-" <> prepend_prefix(value, base)
-  end
-
   defp prepend_prefix(value, base) do
-    prefix =
-      case base do
-        :binary -> "0b"
-        :octal -> "0o"
-        :hex -> "0x"
-      end
-
+    prefix = case base do
+      :binary -> "0b"
+      :octal  -> "0o"
+      :hex    -> "0x"
+    end
     prefix <> value
   end
 end
 
 defimpl Inspect, for: Float do
-  def inspect(term, opts) do
-    inspected = IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
-    color(inspected, :number, opts)
+  def inspect(term, _opts) do
+    IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
   end
 end
 
 defimpl Inspect, for: Regex do
-  def inspect(regex, opts) do
-    {escaped, _} = Identifier.escape(regex.source, ?/, :infinity, &escape_map/1)
-    source = IO.iodata_to_binary(['~r/', escaped, ?/, regex.opts])
-    color(source, :regex, opts)
+  def inspect(regex, _opts) do
+    delim = ?/
+    concat ["~r",
+            <<delim, escape(regex.source, delim)::binary, delim>>,
+            regex.opts]
   end
 
-  defp escape_map(?\a), do: '\\a'
-  defp escape_map(?\f), do: '\\f'
-  defp escape_map(?\n), do: '\\n'
-  defp escape_map(?\r), do: '\\r'
-  defp escape_map(?\t), do: '\\t'
-  defp escape_map(?\v), do: '\\v'
-  defp escape_map(_), do: false
+  defp escape(bin, term),
+    do: escape(bin, <<>>, term)
+
+  defp escape(<<?\\, term>> <> rest, buf, term),
+    do: escape(rest, buf <> <<?\\, term>>, term)
+
+  defp escape(<<term>> <> rest, buf, term),
+    do: escape(rest, buf <> <<?\\, term>>, term)
+
+  # the list of characters is from "String.printable?" impl
+  # minus characters treated specially by regex: \s, \d, \b, \e
+
+  defp escape(<<?\n>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?n>>, term)
+
+  defp escape(<<?\r>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?r>>, term)
+
+  defp escape(<<?\t>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?t>>, term)
+
+  defp escape(<<?\v>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?v>>, term)
+
+  defp escape(<<?\f>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?f>>, term)
+
+  defp escape(<<?\a>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?a>>, term)
+
+  defp escape(<<c::utf8>> <> rest, buf, term) do
+    charstr = <<c::utf8>>
+    if String.printable?(charstr) and not c in [?\d, ?\b, ?\e] do
+      escape(rest, buf <> charstr, term)
+    else
+      escape(rest, buf <> Inspect.BitString.escape_char(c), term)
+    end
+  end
+
+  defp escape(<<c>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, Inspect.BitString.escape_char(c)>>, term)
+
+  defp escape(<<>>, buf, _), do: buf
 end
 
 defimpl Inspect, for: Function do
   def inspect(function, _opts) do
-    fun_info = Function.info(function)
+    fun_info = :erlang.fun_info(function)
     mod = fun_info[:module]
-    name = fun_info[:name]
 
-    cond do
-      fun_info[:type] == :external and fun_info[:env] == [] ->
-        inspected_as_atom = Identifier.inspect_as_atom(mod)
-        inspected_as_function = Identifier.inspect_as_function(name)
-        "&#{inspected_as_atom}.#{inspected_as_function}/#{fun_info[:arity]}"
-
-      match?('elixir_compiler_' ++ _, Atom.to_charlist(mod)) ->
-        if function_exported?(mod, :__RELATIVE__, 0) do
-          "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
-        else
+    if fun_info[:type] == :external and fun_info[:env] == [] do
+      "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
+    else
+      case Atom.to_charlist(mod) do
+        'elixir_compiler_' ++ _ ->
+          if function_exported?(mod, :__RELATIVE__, 0) do
+            "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
+          else
+            default_inspect(mod, fun_info)
+          end
+        _ ->
           default_inspect(mod, fun_info)
-        end
-
-      true ->
-        default_inspect(mod, fun_info)
+      end
     end
   end
 
   defp default_inspect(mod, fun_info) do
-    inspected_as_atom = Identifier.inspect_as_atom(mod)
-    extracted_name = extract_name(fun_info[:name])
-    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in #{inspected_as_atom}#{extracted_name}>"
+    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in " <>
+      "#{Inspect.Atom.inspect(mod)}#{extract_name(fun_info[:name])}>"
   end
 
   defp extract_name([]) do
@@ -338,17 +495,16 @@ defimpl Inspect, for: Function do
   end
 
   defp extract_name(name) do
-    case Identifier.extract_anonymous_fun_parent(name) do
-      {name, arity} ->
-        "." <> Identifier.inspect_as_function(name) <> "/" <> arity
-
-      :error ->
-        "." <> Identifier.inspect_as_function(name)
+    name = Atom.to_string(name)
+    case :binary.split(name, "-", [:global]) do
+      ["", name | _] -> "." <> name
+      _ -> "." <> name
     end
   end
 
   defp uniq(fun_info) do
-    Integer.to_string(fun_info[:new_index]) <> "." <> Integer.to_string(fun_info[:uniq])
+    Integer.to_string(fun_info[:new_index]) <> "." <>
+      Integer.to_string(fun_info[:uniq])
   end
 end
 
@@ -360,7 +516,7 @@ end
 
 defimpl Inspect, for: Port do
   def inspect(port, _opts) do
-    IO.iodata_to_binary(:erlang.port_to_list(port))
+    IO.iodata_to_binary :erlang.port_to_list(port)
   end
 end
 
@@ -372,19 +528,18 @@ defimpl Inspect, for: Reference do
 end
 
 defimpl Inspect, for: Any do
-  def inspect(%module{} = struct, opts) do
+  def inspect(%{__struct__: struct} = map, opts) do
     try do
-      module.__struct__
+      struct.__struct__
     rescue
-      _ -> Inspect.Map.inspect(struct, opts)
+      _ -> Inspect.Map.inspect(map, opts)
     else
       dunder ->
-        if :maps.keys(dunder) == :maps.keys(struct) do
-          pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, struct))
-          colorless_opts = %{opts | syntax_colors: []}
-          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(module, colorless_opts), opts)
+        if :maps.keys(dunder) == :maps.keys(map) do
+          pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, map))
+          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, opts), opts)
         else
-          Inspect.Map.inspect(struct, opts)
+          Inspect.Map.inspect(map, opts)
         end
     end
   end

lib/elixir/lib/integer.ex

@@ -1,15 +1,6 @@
 defmodule Integer do
   @moduledoc """
   Functions for working with integers.
-
-  Some functions that work on integers are found in `Kernel`:
-
-    * `abs/2`
-    * `div/2`
-    * `max/2`
-    * `min/2`
-    * `rem/2`
-
   """
 
   import Bitwise
@@ -37,7 +28,9 @@ defmodule Integer do
       false
 
   """
-  defguard is_odd(integer) when is_integer(integer) and (integer &&& 1) == 1
+  defmacro is_odd(integer) do
+    quote do: (unquote(integer) &&& 1) == 1
+  end
 
   @doc """
   Determines if an `integer` is even.
@@ -62,103 +55,44 @@ defmodule Integer do
       true
 
   """
-  defguard is_even(integer) when is_integer(integer) and (integer &&& 1) == 0
-
-  @doc """
-  Computes the modulo remainder of an integer division.
-
-  `Integer.mod/2` uses floored division, which means that
-  the result will always have the sign of the `divisor`.
-
-  Raises an `ArithmeticError` exception if one of the arguments is not an
-  integer, or when the `divisor` is `0`.
-
-  ## Examples
-
-      iex> Integer.mod(5, 2)
-      1
-      iex> Integer.mod(6, -4)
-      -2
-
-  """
-  @doc since: "1.4.0"
-  @spec mod(integer, neg_integer | pos_integer) :: integer
-  def mod(dividend, divisor) do
-    remainder = rem(dividend, divisor)
-
-    if remainder * divisor < 0 do
-      remainder + divisor
-    else
-      remainder
-    end
+  defmacro is_even(integer) do
+    quote do: (unquote(integer) &&& 1) == 0
   end
 
   @doc """
-  Performs a floored integer division.
-
-  Raises an `ArithmeticError` exception if one of the arguments is not an
-  integer, or when the `divisor` is `0`.
-
-  `Integer.floor_div/2` performs *floored* integer division. This means that
-  the result is always rounded towards negative infinity.
-
-  If you want to perform truncated integer division (rounding towards zero),
-  use `Kernel.div/2` instead.
-
-  ## Examples
-
-      iex> Integer.floor_div(5, 2)
-      2
-      iex> Integer.floor_div(6, -4)
-      -2
-      iex> Integer.floor_div(-99, 2)
-      -50
-
-  """
-  @doc since: "1.4.0"
-  @spec floor_div(integer, neg_integer | pos_integer) :: integer
-  def floor_div(dividend, divisor) do
-    if dividend * divisor < 0 and rem(dividend, divisor) != 0 do
-      div(dividend, divisor) - 1
-    else
-      div(dividend, divisor)
-    end
-  end
-
-  @doc """
-  Returns the ordered digits for the given `integer`.
+  Returns the ordered digits for the given non-negative `integer`.
 
   An optional `base` value may be provided representing the radix for the returned
-  digits. This one must be an integer >= 2.
+  digits. This one can be an integer >= 2.
 
   ## Examples
 
-      iex> Integer.digits(123)
-      [1, 2, 3]
+      iex> Integer.digits(101)
+      [1, 0, 1]
 
       iex> Integer.digits(170, 2)
       [1, 0, 1, 0, 1, 0, 1, 0]
 
-      iex> Integer.digits(-170, 2)
-      [-1, 0, -1, 0, -1, 0, -1, 0]
-
   """
-  @spec digits(integer, pos_integer) :: [integer, ...]
+  @spec digits(non_neg_integer, pos_integer) :: [non_neg_integer, ...]
   def digits(integer, base \\ 10)
-      when is_integer(integer) and is_integer(base) and base >= 2 do
+      when is_integer(integer) and integer >= 0 and is_integer(base) and base >= 2 do
     do_digits(integer, base, [])
   end
 
-  defp do_digits(integer, base, acc) when abs(integer) < base, do: [integer | acc]
-
-  defp do_digits(integer, base, acc),
-    do: do_digits(div(integer, base), base, [rem(integer, base) | acc])
+  defp do_digits(0, _base, []), do: [0]
+  defp do_digits(1, _base, []), do: [1]
+  defp do_digits(base, base, []), do: [1, 0]
+  defp do_digits(0, _base, acc), do: acc
+  defp do_digits(integer, base, acc) do
+    do_digits div(integer, base), base, [rem(integer, base) | acc]
+  end
 
   @doc """
   Returns the integer represented by the ordered `digits`.
 
   An optional `base` value may be provided representing the radix for the `digits`.
-  Base has to be an integer greater or equal than `2`.
+  This one can be an integer >= 2.
 
   ## Examples
 
@@ -172,18 +106,19 @@ defmodule Integer do
       0
 
   """
-  @spec undigits([integer], pos_integer) :: integer
+  @spec undigits([integer], integer) :: integer
   def undigits(digits, base \\ 10) when is_list(digits) and is_integer(base) and base >= 2 do
     do_undigits(digits, base, 0)
   end
 
+  defp do_undigits([], _base, []), do: 0
+  defp do_undigits([0], _base, []), do: 0
+  defp do_undigits([1], _base, []), do: 1
+  defp do_undigits([1, 0], base, []), do: base
   defp do_undigits([], _base, acc), do: acc
-
-  defp do_undigits([digit | _], base, _) when is_integer(digit) and digit >= base,
-    do: raise(ArgumentError, "invalid digit #{digit} in base #{base}")
-
-  defp do_undigits([digit | tail], base, acc) when is_integer(digit),
-    do: do_undigits(tail, base, acc * base + digit)
+  defp do_undigits([digit | tail], base, acc) do
+    do_undigits(tail, base, acc * base + digit)
+  end
 
   @doc """
   Parses a text representation of an integer.
@@ -196,7 +131,7 @@ defmodule Integer do
 
   Raises an error if `base` is less than 2 or more than 36.
 
-  If you want to convert a string-formatted integer directly to an integer,
+  If you want to convert a string-formatted integer directly to a integer,
   `String.to_integer/1` or `String.to_integer/2` can be used instead.
 
   ## Examples
@@ -226,48 +161,74 @@ defmodule Integer do
       ** (ArgumentError) invalid base 38
 
   """
-  @spec parse(binary, 2..36) :: {integer, binary} | :error
+  @spec parse(binary, 2..36) :: {integer, binary} | :error | no_return
   def parse(binary, base \\ 10)
 
-  def parse(_binary, base) when base not in 2..36 do
-    raise ArgumentError, "invalid base #{inspect(base)}"
+  def parse("", base) when base in 2..36,
+    do: :error
+
+  def parse(binary, base) when is_binary(binary) and base in 2..36 do
+    parse_in_base(binary, base)
   end
 
-  def parse(binary, base) do
-    case count_digits(binary, base) do
-      0 ->
-        :error
+  def parse(binary, base) when is_binary(binary) do
+    raise ArgumentError, "invalid base #{base}"
+  end
 
-      count ->
-        {digits, rem} = :erlang.split_binary(binary, count)
-        {:erlang.binary_to_integer(digits, base), rem}
+  defp parse_in_base("-" <> bin, base) do
+    case do_parse(bin, base) do
+      {number, remainder} -> {-number, remainder}
+      :error -> :error
     end
   end
 
-  defp count_digits(<<sign, rest::binary>>, base) when sign in '+-' do
-    case count_digits_nosign(rest, base, 1) do
-      1 -> 0
-      count -> count
+  defp parse_in_base("+" <> bin, base) do
+    do_parse(bin, base)
+  end
+
+  defp parse_in_base(binary, base) when is_binary(binary) do
+    do_parse(binary, base)
+  end
+
+  defp do_parse(<<char, rest::binary>>, base) do
+    if valid_digit_in_base?(char, base) do
+      do_parse(rest, base, parse_digit(char, base))
+    else
+      :error
     end
   end
 
-  defp count_digits(<<rest::binary>>, base) do
-    count_digits_nosign(rest, base, 0)
+  defp do_parse(_, _) do
+    :error
   end
 
-  digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]
-
-  for {chars, diff} <- digits,
-      char <- chars do
-    digit = char + diff
-
-    defp count_digits_nosign(<<unquote(char), rest::binary>>, base, count)
-         when base > unquote(digit) do
-      count_digits_nosign(rest, base, count + 1)
+  defp do_parse(<<char, rest::binary>> = bin, base, acc) do
+    if valid_digit_in_base?(char, base) do
+      do_parse(rest, base, base * acc + parse_digit(char, base))
+    else
+      {acc, bin}
     end
   end
 
-  defp count_digits_nosign(<<_::binary>>, _, count), do: count
+  defp do_parse(bitstring, _, acc) do
+    {acc, bitstring}
+  end
+
+  defp parse_digit(char, _) do
+    cond do
+      char in ?0..?9 -> char - ?0
+      char in ?A..?Z -> char - ?A + 10
+      true           -> char - ?a + 10
+    end
+  end
+
+  defp valid_digit_in_base?(char, base) do
+    if base <= 10 do
+      char in ?0..(?0 + base - 1)
+    else
+      char in ?0..?9 or char in ?A..(?A + base - 11) or char in ?a..(?a + base - 11)
+    end
+  end
 
   @doc """
   Returns a binary which corresponds to the text representation
@@ -290,7 +251,7 @@ defmodule Integer do
       "123"
 
   """
-  @spec to_string(integer) :: String.t()
+  @spec to_string(integer) :: String.t
   def to_string(integer) do
     :erlang.integer_to_binary(integer)
   end
@@ -311,11 +272,11 @@ defmodule Integer do
       iex> Integer.to_string(-100, 16)
       "-64"
 
-      iex> Integer.to_string(882_681_651, 36)
+      iex> Integer.to_string(882681651, 36)
       "ELIXIR"
 
   """
-  @spec to_string(integer, 2..36) :: String.t()
+  @spec to_string(integer, 2..36) :: String.t
   def to_string(integer, base) do
     :erlang.integer_to_binary(integer, base)
   end
@@ -360,7 +321,7 @@ defmodule Integer do
       iex> Integer.to_charlist(-100, 16)
       '-64'
 
-      iex> Integer.to_charlist(882_681_651, 36)
+      iex> Integer.to_charlist(882681651, 36)
       'ELIXIR'
 
   """
@@ -369,53 +330,8 @@ defmodule Integer do
     :erlang.integer_to_list(integer, base)
   end
 
-  @doc """
-  Returns the greatest common divisor of the two given integers.
-
-  The greatest common divisor (GCD) of `integer1` and `integer2` is the largest positive
-  integer that divides both `integer1` and `integer2` without leaving a remainder.
-
-  By convention, `gcd(0, 0)` returns `0`.
-
-  ## Examples
-
-      iex> Integer.gcd(2, 3)
-      1
-
-      iex> Integer.gcd(8, 12)
-      4
-
-      iex> Integer.gcd(8, -12)
-      4
-
-      iex> Integer.gcd(10, 0)
-      10
-
-      iex> Integer.gcd(7, 7)
-      7
-
-      iex> Integer.gcd(0, 0)
-      0
-
-  """
-  @doc since: "1.5.0"
-  @spec gcd(0, 0) :: 0
-  @spec gcd(integer, integer) :: pos_integer
-  def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
-    gcd_positive(abs(integer1), abs(integer2))
-  end
-
-  defp gcd_positive(0, integer2), do: integer2
-  defp gcd_positive(integer1, 0), do: integer1
-  defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))
-
-  # TODO: Remove by 2.0
+  # TODO: Deprecate by v1.5
   @doc false
-  @deprecated "Use Integer.to_charlist/1 instead"
+  @spec to_char_list(integer) :: charlist
   def to_char_list(integer), do: Integer.to_charlist(integer)
-
-  # TODO: Remove by 2.0
-  @doc false
-  @deprecated "Use Integer.to_charlist/2 instead"
-  def to_char_list(integer, base), do: Integer.to_charlist(integer, base)
 end

lib/elixir/lib/io.ex

@@ -3,7 +3,7 @@ defmodule IO do
   Functions handling input/output (IO).
 
   Many functions in this module expect an IO device as an argument.
-  An IO device must be a PID or an atom representing a process.
+  An IO device must be a pid or an atom representing a process.
   For convenience, Elixir provides `:stdio` and `:stderr` as
   shortcuts to Erlang's `:standard_io` and `:standard_error`.
 
@@ -17,7 +17,7 @@ defmodule IO do
 
   ## IO devices
 
-  An IO device may be an atom or a PID. In case it is an atom,
+  An IO device may be an atom or a pid. In case it is an atom,
   the atom must be the name of a registered process. In addition,
   Elixir provides two shortcuts:
 
@@ -27,9 +27,9 @@ defmodule IO do
     * `:stderr` - a shortcut for the named process `:standard_error`
       provided in Erlang
 
-  IO devices maintain their position, which means subsequent calls to any
-  reading or writing functions will start from the place where the device
-  was last accessed. The position of files can be changed using the
+  IO devices maintain their position, that means subsequent calls to any
+  reading or writing functions will start from the place when the device
+  was last accessed. Position of files can be changed using the
   `:file.position/2` function.
 
   """
@@ -38,6 +38,8 @@ defmodule IO do
   @type nodata :: {:error, term} | :eof
   @type chardata() :: :unicode.chardata()
 
+  import :erlang, only: [group_leader: 0]
+
   defmacrop is_iodata(data) do
     quote do
       is_list(unquote(data)) or is_binary(unquote(data))
@@ -53,7 +55,7 @@ defmodule IO do
 
   It returns:
 
-    * `data` - the output characters
+    * `data` - the input characters
 
     * `:eof` - end of file was encountered
 
@@ -65,7 +67,7 @@ defmodule IO do
   empty string in case the device has reached EOF.
   """
   @spec read(device, :all | :line | non_neg_integer) :: chardata | nodata
-  def read(device \\ :stdio, line_or_chars)
+  def read(device \\ group_leader(), line_or_chars)
 
   def read(device, :all) do
     do_read_all(map_dev(device), "")
@@ -90,13 +92,13 @@ defmodule IO do
   @doc """
   Reads from the IO `device`. The operation is Unicode unsafe.
 
-  The `device` is iterated by the given number of bytes or line by line if
+  The `device` is iterated by the given number of characters or line by line if
   `:line` is given.
   Alternatively, if `:all` is given, then whole `device` is returned.
 
   It returns:
 
-    * `data` - the output bytes
+    * `data` - the input characters
 
     * `:eof` - end of file was encountered
 
@@ -111,7 +113,7 @@ defmodule IO do
   as it will return the wrong result.
   """
   @spec binread(device, :all | :line | non_neg_integer) :: iodata | nodata
-  def binread(device \\ :stdio, line_or_chars)
+  def binread(device \\ group_leader(), line_or_chars)
 
   def binread(device, :all) do
     do_binread_all(map_dev(device), "")
@@ -143,7 +145,8 @@ defmodule IO do
   @doc """
   Writes `item` to the given `device`.
 
-  By default, the `device` is the standard output.
+  By default the `device` is the standard output.
+  It returns `:ok` if it succeeds.
 
   ## Examples
 
@@ -154,9 +157,9 @@ defmodule IO do
       #=> error
 
   """
-  @spec write(device, chardata | String.Chars.t()) :: :ok
-  def write(device \\ :stdio, item) do
-    :io.put_chars(map_dev(device), to_chardata(item))
+  @spec write(device, chardata | String.Chars.t) :: :ok
+  def write(device \\ group_leader(), item) do
+    :io.put_chars map_dev(device), to_chardata(item)
   end
 
   @doc """
@@ -170,29 +173,17 @@ defmodule IO do
   as it will return the wrong result.
   """
   @spec binwrite(device, iodata) :: :ok | {:error, term}
-  def binwrite(device \\ :stdio, item) when is_iodata(item) do
-    :file.write(map_dev(device), item)
+  def binwrite(device \\ group_leader(), item) when is_iodata(item) do
+    :file.write map_dev(device), item
   end
 
   @doc """
   Writes `item` to the given `device`, similar to `write/2`,
   but adds a newline at the end.
-
-  By default, the `device` is the standard output. It returns `:ok`
-  if it succeeds.
-
-  ## Examples
-
-      IO.puts "Hello World!"
-      #=> Hello World!
-
-      IO.puts :stderr, "error"
-      #=> error
-
   """
-  @spec puts(device, chardata | String.Chars.t()) :: :ok
-  def puts(device \\ :stdio, item) do
-    :io.put_chars(map_dev(device), [to_chardata(item), ?\n])
+  @spec puts(device, chardata | String.Chars.t) :: :ok
+  def puts(device \\ group_leader(), item) do
+    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
   end
 
   @doc """
@@ -212,17 +203,13 @@ defmodule IO do
       #=>   my_app.ex:4: MyApp.main/1
 
   """
-  @spec warn(chardata | String.Chars.t(), Exception.stacktrace()) :: :ok
+  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
   def warn(message, []) do
-    :elixir_errors.bare_warn(nil, nil, [to_chardata(message), ?\n])
+    :elixir_errors.warn([to_chardata(message), ?\n])
   end
-
-  def warn(message, [{_, _, _, opts} | _] = stacktrace) do
-    formatted_trace = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
-    message = [to_chardata(message), ?\n, "  ", formatted_trace, ?\n]
-    line = opts[:line]
-    file = opts[:file]
-    :elixir_errors.bare_warn(line, file && List.to_string(file), message)
+  def warn(message, stacktrace) when is_list(stacktrace) do
+    formatted = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
+    :elixir_errors.warn([to_chardata(message), ?\n, "  ", formatted, ?\n])
   end
 
   @doc """
@@ -237,7 +224,7 @@ defmodule IO do
       #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
 
   """
-  @spec warn(chardata | String.Chars.t()) :: :ok
+  @spec warn(chardata | String.Chars.t) :: :ok
   def warn(message) do
     {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
     warn(message, Enum.drop(stacktrace, 2))
@@ -246,68 +233,32 @@ defmodule IO do
   @doc """
   Inspects and writes the given `item` to the device.
 
-  It's important to note that it returns the given `item` unchanged.
-  This makes it possible to "spy" on values by inserting an
-  `IO.inspect/2` call almost anywhere in your code, for example,
-  in the middle of a pipeline.
-
   It enables pretty printing by default with width of
   80 characters. The width can be changed by explicitly
   passing the `:width` option.
 
-  The output can be decorated with a label, by providing the `:label`
-  option to easily distinguish it from other `IO.inspect/2` calls.
-  The label will be printed before the inspected `item`.
-
-  See `Inspect.Opts` for a full list of remaining formatting options.
+  See `Inspect.Opts` for a full list of options.
 
   ## Examples
 
-      IO.inspect <<0, 1, 2>>, width: 40
-
-  Prints:
-
-      <<0, 1, 2>>
-
-  We can use the `:label` option to decorate the output:
-
-      IO.inspect 1..100, label: "a wonderful range"
-
-  Prints:
-
-      a wonderful range: 1..100
-
-  The `:label` option is especially useful with pipelines:
-
-      [1, 2, 3]
-      |> IO.inspect(label: "before")
-      |> Enum.map(&(&1 * 2))
-      |> IO.inspect(label: "after")
-      |> Enum.sum
-
-  Prints:
-
-      before: [1, 2, 3]
-      after: [2, 4, 6]
+      IO.inspect Process.list, width: 40
 
   """
-  @spec inspect(item, keyword) :: item when item: var
+  @spec inspect(item, Keyword.t) :: item when item: var
   def inspect(item, opts \\ []) do
-    inspect(:stdio, item, opts)
+    inspect group_leader(), item, opts
   end
 
   @doc """
   Inspects `item` according to the given options using the IO `device`.
 
-  See `inspect/2` for a full list of options.
+  See `Inspect.Opts` for a full list of options.
   """
-  @spec inspect(device, item, keyword) :: item when item: var
+  @spec inspect(device, item, Keyword.t) :: item when item: var
   def inspect(device, item, opts) when is_list(opts) do
-    label = if label = opts[:label], do: [to_chardata(label), ": "], else: []
-    opts = struct(Inspect.Opts, opts)
-    doc = Inspect.Algebra.group(Inspect.Algebra.to_doc(item, opts))
-    chardata = Inspect.Algebra.format(doc, opts.width)
-    puts(device, [label, chardata])
+    opts   = struct(Inspect.Opts, opts)
+    iodata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), opts.width)
+    puts device, iodata
     item
   end
 
@@ -321,12 +272,12 @@ defmodule IO do
   See `IO.getn/3` for a description of return values.
 
   """
-  @spec getn(chardata | String.Chars.t(), pos_integer) :: chardata | nodata
-  @spec getn(device, chardata | String.Chars.t()) :: chardata | nodata
+  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
+  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
   def getn(prompt, count \\ 1)
 
   def getn(prompt, count) when is_integer(count) and count > 0 do
-    getn(:stdio, prompt, count)
+    getn(group_leader, prompt, count)
   end
 
   def getn(device, prompt) when not is_integer(prompt) do
@@ -351,12 +302,12 @@ defmodule IO do
       NFS volume
 
   """
-  @spec getn(device, chardata | String.Chars.t(), pos_integer) :: chardata | nodata
+  @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
   def getn(device, prompt, count) when is_integer(count) and count > 0 do
     :io.get_chars(map_dev(device), to_chardata(prompt), count)
   end
 
-  @doc ~S"""
+  @doc """
   Reads a line from the IO `device`.
 
   It returns:
@@ -377,8 +328,8 @@ defmodule IO do
       IO.gets "What is your name?\n"
 
   """
-  @spec gets(device, chardata | String.Chars.t()) :: chardata | nodata
-  def gets(device \\ :stdio, prompt) do
+  @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
+  def gets(device \\ group_leader(), prompt) do
     :io.get_line(map_dev(device), to_chardata(prompt))
   end
 
@@ -392,7 +343,7 @@ defmodule IO do
   The `device` is iterated by the given number of characters or line by line if
   `:line` is given.
 
-  This reads from the IO as UTF-8. Check out
+  This reads from the IO as utf-8. Check out
   `IO.binstream/2` to handle the IO as a raw binary.
 
   Note that an IO stream has side effects and every time
@@ -406,7 +357,7 @@ defmodule IO do
       Enum.each IO.stream(:stdio, :line), &IO.write(&1)
 
   """
-  @spec stream(device, :line | pos_integer) :: Enumerable.t()
+  @spec stream(device, :line | pos_integer) :: Enumerable.t
   def stream(device, line_or_codepoints)
       when line_or_codepoints == :line
       when is_integer(line_or_codepoints) and line_or_codepoints > 0 do
@@ -431,7 +382,7 @@ defmodule IO do
   mode as it will return the wrong result.
 
   """
-  @spec binstream(device, :line | pos_integer) :: Enumerable.t()
+  @spec binstream(device, :line | pos_integer) :: Enumerable.t
   def binstream(device, line_or_bytes)
       when line_or_bytes == :line
       when is_integer(line_or_bytes) and line_or_bytes > 0 do
@@ -457,7 +408,7 @@ defmodule IO do
       "string"
 
   """
-  @spec chardata_to_string(chardata) :: String.t() | no_return
+  @spec chardata_to_string(chardata) :: String.t | no_return
   def chardata_to_string(string) when is_binary(string) do
     string
   end
@@ -519,10 +470,8 @@ defmodule IO do
     case read(device, line_or_codepoints) do
       :eof ->
         {:halt, device}
-
       {:error, reason} ->
         raise IO.StreamError, reason: reason
-
       data ->
         {[data], device}
     end
@@ -533,10 +482,8 @@ defmodule IO do
     case binread(device, line_or_chars) do
       :eof ->
         {:halt, device}
-
       {:error, reason} ->
         raise IO.StreamError, reason: reason
-
       data ->
         {[data], device}
     end
@@ -545,7 +492,7 @@ defmodule IO do
   @compile {:inline, map_dev: 1, to_chardata: 1}
 
   # Map the Elixir names for standard IO and error to Erlang names
-  defp map_dev(:stdio), do: :standard_io
+  defp map_dev(:stdio),  do: :standard_io
   defp map_dev(:stderr), do: :standard_error
   defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other
 

lib/elixir/lib/io/ansi.ex

@@ -25,10 +25,9 @@ defmodule IO.ANSI do
 
   import IO.ANSI.Sequence
 
-  @type ansicode :: atom
-  @type ansilist ::
-          maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
-  @type ansidata :: ansilist | ansicode | binary
+  @typep ansicode :: atom
+  @typep ansilist :: maybe_improper_list(char | ansicode | binary | ansilist, binary | ansicode | [])
+  @type  ansidata :: ansilist | ansicode | binary
 
   @doc """
   Checks if ANSI coloring is supported and enabled on this machine.
@@ -43,8 +42,8 @@ defmodule IO.ANSI do
     Application.get_env(:elixir, :ansi_enabled, false)
   end
 
-  @doc "Sets foreground color."
-  @spec color(0..255) :: String.t()
+  @doc "Sets foreground color"
+  @spec color(0..255) :: String.t
   def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
 
   @doc ~S"""
@@ -52,13 +51,13 @@ defmodule IO.ANSI do
 
   Valid values for each color are in the range 0 to 5.
   """
-  @spec color(0..5, 0..5, 0..5) :: String.t()
+  @spec color(0..5, 0..5, 0..5) :: String.t
   def color(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color(16 + 36 * r + 6 * g + b)
+    color(16 + (36 * r) + (6 * g) + b)
   end
 
-  @doc "Sets background color."
-  @spec color_background(0..255) :: String.t()
+  @doc "Sets background color"
+  @spec color_background(0..255) :: String.t
   def color_background(code) when code in 0..255, do: "\e[48;5;#{code}m"
 
   @doc ~S"""
@@ -66,145 +65,106 @@ defmodule IO.ANSI do
 
   Valid values for each color are in the range 0 to 5.
   """
-  @spec color_background(0..5, 0..5, 0..5) :: String.t()
+  @spec color_background(0..5, 0..5, 0..5) :: String.t
   def color_background(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color_background(16 + 36 * r + 6 * g + b)
+    color_background(16 + (36 * r) + (6 * g) + b)
   end
 
-  @doc "Resets all attributes."
-  defsequence(:reset, 0)
+  @doc "Resets all attributes"
+  defsequence :reset, 0
 
-  @doc "Bright (increased intensity) or bold."
-  defsequence(:bright, 1)
+  @doc "Bright (increased intensity) or Bold"
+  defsequence :bright, 1
 
-  @doc "Faint (decreased intensity). Not widely supported."
-  defsequence(:faint, 2)
+  @doc "Faint (decreased intensity), not widely supported"
+  defsequence :faint, 2
 
-  @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
-  defsequence(:italic, 3)
+  @doc "Italic: on. Not widely supported. Sometimes treated as inverse"
+  defsequence :italic, 3
 
-  @doc "Underline: single."
-  defsequence(:underline, 4)
+  @doc "Underline: Single"
+  defsequence :underline, 4
 
-  @doc "Blink: slow. Less than 150 per minute."
-  defsequence(:blink_slow, 5)
+  @doc "Blink: Slow. Less than 150 per minute"
+  defsequence :blink_slow, 5
 
-  @doc "Blink: rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported."
-  defsequence(:blink_rapid, 6)
+  @doc "Blink: Rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported"
+  defsequence :blink_rapid, 6
 
-  @doc "Image: negative. Swap foreground and background."
-  defsequence(:inverse, 7)
+  @doc "Image: Negative. Swap foreground and background"
+  defsequence :inverse, 7
 
-  @doc "Image: negative. Swap foreground and background."
-  defsequence(:reverse, 7)
+  @doc "Image: Negative. Swap foreground and background"
+  defsequence :reverse, 7
 
-  @doc "Conceal. Not widely supported."
-  defsequence(:conceal, 8)
+  @doc "Conceal. Not widely supported"
+  defsequence :conceal, 8
 
-  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
-  defsequence(:crossed_out, 9)
+  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported"
+  defsequence :crossed_out, 9
 
-  @doc "Sets primary (default) font."
-  defsequence(:primary_font, 10)
+  @doc "Sets primary (default) font"
+  defsequence :primary_font, 10
 
   for font_n <- [1, 2, 3, 4, 5, 6, 7, 8, 9] do
-    @doc "Sets alternative font #{font_n}."
-    defsequence(:"font_#{font_n}", font_n + 10)
+    @doc "Sets alternative font #{font_n}"
+    defsequence :"font_#{font_n}", font_n + 10
   end
 
-  @doc "Normal color or intensity."
-  defsequence(:normal, 22)
+  @doc "Normal color or intensity"
+  defsequence :normal, 22
 
-  @doc "Not italic."
-  defsequence(:not_italic, 23)
+  @doc "Not italic"
+  defsequence :not_italic, 23
 
-  @doc "Underline: none."
-  defsequence(:no_underline, 24)
+  @doc "Underline: None"
+  defsequence :no_underline, 24
 
-  @doc "Blink: off."
-  defsequence(:blink_off, 25)
-
-  @doc "Image: positive. Normal foreground and background."
-  defsequence(:inverse_off, 27)
-
-  @doc "Image: positive. Normal foreground and background."
-  defsequence(:reverse_off, 27)
+  @doc "Blink: off"
+  defsequence :blink_off, 25
 
   colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
 
   for {color, code} <- Enum.with_index(colors) do
-    @doc "Sets foreground color to #{color}."
-    defsequence(color, code + 30)
+    @doc "Sets foreground color to #{color}"
+    defsequence color, code + 30
 
-    @doc "Sets foreground color to light #{color}."
-    defsequence(:"light_#{color}", code + 90)
-
-    @doc "Sets background color to #{color}."
-    defsequence(:"#{color}_background", code + 40)
-
-    @doc "Sets background color to light #{color}."
-    defsequence(:"light_#{color}_background", code + 100)
+    @doc "Sets background color to #{color}"
+    defsequence :"#{color}_background", code + 40
   end
 
-  @doc "Default text color."
-  defsequence(:default_color, 39)
+  @doc "Default text color"
+  defsequence :default_color, 39
 
-  @doc "Default background color."
-  defsequence(:default_background, 49)
+  @doc "Default background color"
+  defsequence :default_background, 49
 
-  @doc "Framed."
-  defsequence(:framed, 51)
+  @doc "Framed"
+  defsequence :framed, 51
 
-  @doc "Encircled."
-  defsequence(:encircled, 52)
+  @doc "Encircled"
+  defsequence :encircled, 52
 
-  @doc "Overlined."
-  defsequence(:overlined, 53)
+  @doc "Overlined"
+  defsequence :overlined, 53
 
-  @doc "Not framed or encircled."
-  defsequence(:not_framed_encircled, 54)
+  @doc "Not framed or encircled"
+  defsequence :not_framed_encircled, 54
 
-  @doc "Not overlined."
-  defsequence(:not_overlined, 55)
+  @doc "Not overlined"
+  defsequence :not_overlined, 55
 
-  @doc "Sends cursor home."
-  defsequence(:home, "", "H")
+  @doc "Sends cursor home"
+  defsequence :home, "", "H"
 
-  @doc """
-  Sends cursor to the absolute position specified by `line` and `column`.
+  @doc "Clears screen"
+  defsequence :clear, "2", "J"
 
-  Line `0` and column `0` would mean the top left corner.
-  """
-  @spec cursor(non_neg_integer, non_neg_integer) :: String.t()
-  def cursor(line, column)
-      when is_integer(line) and line >= 0 and is_integer(column) and column >= 0 do
-    "\e[#{line};#{column}H"
-  end
-
-  @doc "Sends cursor `lines` up."
-  @spec cursor_up(pos_integer) :: String.t()
-  def cursor_up(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}A"
-
-  @doc "Sends cursor `lines` down."
-  @spec cursor_down(pos_integer) :: String.t()
-  def cursor_down(lines \\ 1) when is_integer(lines) and lines >= 1, do: "\e[#{lines}B"
-
-  @doc "Sends cursor `columns` to the right."
-  @spec cursor_right(pos_integer) :: String.t()
-  def cursor_right(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}C"
-
-  @doc "Sends cursor `columns` to the left."
-  @spec cursor_left(pos_integer) :: String.t()
-  def cursor_left(columns \\ 1) when is_integer(columns) and columns >= 1, do: "\e[#{columns}D"
-
-  @doc "Clears screen."
-  defsequence(:clear, "2", "J")
-
-  @doc "Clears line."
-  defsequence(:clear_line, "2", "K")
+  @doc "Clears line"
+  defsequence :clear_line, "2", "K"
 
   defp format_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{inspect(other)}"
+    raise ArgumentError, "invalid ANSI sequence specification: #{inspect other}"
   end
 
   @doc ~S"""
@@ -226,7 +186,7 @@ defmodule IO.ANSI do
       [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
 
   """
-  def format(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
+  def format(chardata, emit? \\ enabled?) when is_boolean(emit?) do
     do_format(chardata, [], [], emit?, :maybe)
   end
 
@@ -246,7 +206,7 @@ defmodule IO.ANSI do
       [[[[[[] | "\e[1m"], 87], 111], 114], 100]
 
   """
-  def format_fragment(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
+  def format_fragment(chardata, emit? \\ enabled?) when is_boolean(emit?) do
     do_format(chardata, [], [], emit?, false)
   end
 
@@ -271,7 +231,7 @@ defmodule IO.ANSI do
   end
 
   defp do_format([], [], acc, true, true) do
-    [acc | IO.ANSI.reset()]
+    [acc | IO.ANSI.reset]
   end
 
   defp do_format([], [], acc, _emit?, _append_reset) do

lib/elixir/lib/io/ansi/docs.ex

@@ -2,41 +2,35 @@ defmodule IO.ANSI.Docs do
   @moduledoc false
 
   @bullets [?*, ?-, ?+]
-  @spaces [" ", "\n", "\t"]
 
   @doc """
   The default options used by this module.
 
-  The supported keys are:
+  The supported values are:
 
     * `:enabled`           - toggles coloring on and off (true)
     * `:doc_bold`          - bold text (bright)
-    * `:doc_code`          - code blocks (cyan)
-    * `:doc_headings`      - h1, h2, h3, h4, h5, h6 headings (yellow)
-    * `:doc_metadata`      - documentation metadata keys (yellow)
+    * `:doc_code`          - code blocks (cyan, bright)
+    * `:doc_headings`      - h1 and h2 headings (yellow, bright)
     * `:doc_inline_code`   - inline code (cyan)
-    * `:doc_table_heading` - the style for table headings
-    * `:doc_title`         - top level heading (reverse, yellow)
+    * `:doc_table_heading` - style for table headings
+    * `:doc_title`         - top level heading (reverse, yellow, bright)
     * `:doc_underline`     - underlined text (underline)
     * `:width`             - the width to format the text (80)
 
   Values for the color settings are strings with
   comma-separated ANSI values.
   """
-  @spec default_options() :: keyword
   def default_options do
-    [
-      enabled: true,
-      doc_bold: [:bright],
-      doc_code: [:cyan],
-      doc_headings: [:yellow],
-      doc_metadata: [:yellow],
-      doc_inline_code: [:cyan],
-      doc_table_heading: [:reverse],
-      doc_title: [:reverse, :yellow],
-      doc_underline: [:underline],
-      width: 80
-    ]
+    [enabled:           true,
+     doc_bold:          [:bright],
+     doc_code:          [:cyan, :bright],
+     doc_headings:      [:yellow],
+     doc_inline_code:   [:cyan],
+     doc_table_heading: [:reverse],
+     doc_title:         [:reverse, :yellow],
+     doc_underline:     [:underline],
+     width:             80]
   end
 
   @doc """
@@ -44,60 +38,24 @@ defmodule IO.ANSI.Docs do
 
   See `default_options/0` for docs on the supported options.
   """
-  @spec print_heading(String.t(), keyword) :: :ok
   def print_heading(heading, options \\ []) do
-    IO.puts(IO.ANSI.reset())
-    options = Keyword.merge(default_options(), options)
-    width = options[:width]
+    IO.puts IO.ANSI.reset
+    options = Keyword.merge(default_options, options)
+    width   = options[:width]
     padding = div(width + String.length(heading), 2)
     heading = heading |> String.pad_leading(padding) |> String.pad_trailing(width)
     write(:doc_title, heading, options)
-    newline_after_block()
-  end
-
-  @doc """
-  Prints documentation metadata (only `since` and `deprecated` for now).
-
-  See `default_options/0` for docs on the supported options.
-  """
-  @spec print_metadata(map, keyword) :: :ok
-  def print_metadata(metadata, options \\ []) when is_map(metadata) do
-    options = Keyword.merge(default_options(), options)
-    print_each_metadata(metadata, options) && IO.write("\n")
-  end
-
-  @metadata_filter [:deprecated, :since]
-
-  defp print_each_metadata(metadata, options) do
-    Enum.reduce(metadata, false, fn
-      {key, value}, _printed when is_binary(value) and key in @metadata_filter ->
-        label = metadata_label(key, options)
-        indent = String.duplicate(" ", length_without_escape(label, 0) + 1)
-        write_with_wrap([label | String.split(value, @spaces)], options[:width], indent, true)
-
-      _metadata, printed ->
-        printed
-    end)
-  end
-
-  defp metadata_label(key, options) do
-    if options[:enabled] do
-      "#{color(:doc_metadata, options)}#{key}:#{IO.ANSI.reset()}"
-    else
-      "#{key}:"
-    end
+    newline_after_block
   end
 
   @doc """
   Prints the documentation body.
 
   In addition to the printing string, takes a set of options
-  defined in `default_options/0`.
+  defined in `default_options/1`.
   """
-  @spec print(String.t(), keyword) :: :ok
   def print(doc, options \\ []) do
-    options = Keyword.merge(default_options(), options)
-
+    options = Keyword.merge(default_options, options)
     doc
     |> String.split(["\r\n", "\n"], trim: false)
     |> Enum.map(&String.trim_trailing/1)
@@ -108,28 +66,22 @@ defmodule IO.ANSI.Docs do
     write_text(text, indent, options)
   end
 
-  defp process(["# " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
+  defp process(["# " <> heading | rest], text, indent, options) do
+    write_text(text, indent, options)
+    write_h1(String.trim(heading), options)
+    process(rest, [], "", options)
   end
 
-  defp process(["## " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
+  defp process(["## " <> heading | rest], text, indent, options) do
+    write_text(text, indent, options)
+    write_h2(String.trim(heading), options)
+    process(rest, [], "", options)
   end
 
-  defp process(["### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-
-  defp process(["#### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-
-  defp process(["##### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-
-  defp process(["###### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
+  defp process(["### " <> heading | rest], text, indent, options) do
+    write_text(text, indent, options)
+    write_h3(String.trim(heading), indent, options)
+    process(rest, [], "", options)
   end
 
   defp process(["" | rest], text, indent, options) do
@@ -150,18 +102,15 @@ defmodule IO.ANSI.Docs do
     process_fenced_code_block(rest, text, indent, options, _delimiter = "~~~")
   end
 
-  defp process(all = [line | rest], text, indent, options) do
+  defp process(all=[line | rest], text, indent, options) do
     {stripped, count} = strip_spaces(line, 0, :infinity)
-
     cond do
       link_label?(stripped, count) ->
         write_text([line], indent, options, true)
         process(rest, text, indent, options)
-
       table_line?(stripped) and rest != [] and table_line?(hd(rest)) ->
         write_text(text, indent, options)
         process_table(all, indent, options)
-
       true ->
         process_rest(stripped, rest, count, text, indent, options)
     end
@@ -169,11 +118,19 @@ defmodule IO.ANSI.Docs do
 
   ## Headings
 
-  defp write_heading(heading, rest, text, indent, options) do
-    write_text(text, indent, options)
+  defp write_h1(heading, options) do
+    write_h2(String.upcase(heading), options)
+  end
+
+  defp write_h2(heading, options) do
     write(:doc_headings, heading, options)
-    newline_after_block()
-    process(rest, [], "", options)
+    newline_after_block
+  end
+
+  defp write_h3(heading, indent, options) do
+    IO.write(indent)
+    write(:doc_headings, heading, options)
+    newline_after_block
   end
 
   ## Lists
@@ -183,15 +140,12 @@ defmodule IO.ANSI.Docs do
       <<bullet, ?\s, item::binary>> when bullet in @bullets ->
         write_text(text, indent, options)
         process_list("• ", item, rest, count, indent, options)
-
       <<d1, ?., ?\s, item::binary>> when d1 in ?0..?9 ->
         write_text(text, indent, options)
         process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
-
       <<d1, d2, ?., ?\s, item::binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
         write_text(text, indent, options)
         process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
-
       _ ->
         process(rest, [stripped | text], indent, options)
     end
@@ -211,7 +165,6 @@ defmodule IO.ANSI.Docs do
 
   defp process_list_next([line | rest], count, max, acc) do
     {stripped, next_count} = strip_spaces(line, 0, max)
-
     case process_list_next_kind(stripped, rest, count, next_count) do
       :next -> process_list_next(rest, count, max, [stripped | acc])
       :done -> {Enum.reverse(acc), [line | rest], true}
@@ -227,20 +180,14 @@ defmodule IO.ANSI.Docs do
     case {stripped, rest} do
       {<<bullet, ?\s, _::binary>>, _} when bullet in @bullets and next_count <= count ->
         :list
-
       {<<d1, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and next_count <= count ->
         :list
-
-      {<<d1, d2, ?., ?\s, _::binary>>, _}
-      when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
+      {<<d1, d2, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
         :list
-
       {"", [" " <> _ | _]} ->
         :next
-
       {"", _} ->
         :done
-
       _ ->
         :next
     end
@@ -264,7 +211,7 @@ defmodule IO.ANSI.Docs do
     |> Enum.join(" ")
     |> handle_links
     |> handle_inline(options)
-    |> String.split(@spaces)
+    |> String.split(~r{\s})
     |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap)
 
     unless no_wrap, do: newline_after_block()
@@ -308,8 +255,8 @@ defmodule IO.ANSI.Docs do
   end
 
   defp write_code(code, indent, options) do
-    write(:doc_code, "#{indent}    #{Enum.join(Enum.reverse(code), "\n#{indent}    ")}", options)
-    newline_after_block()
+    write(:doc_code, "#{indent}┃ #{Enum.join(Enum.reverse(code), "\n#{indent}┃ ")}", options)
+    newline_after_block
   end
 
   ## Tables
@@ -317,25 +264,22 @@ defmodule IO.ANSI.Docs do
   defp process_table(lines, indent, options) do
     {table, rest} = Enum.split_while(lines, &table_line?/1)
     table_lines(table, options)
-    newline_after_block()
+    newline_after_block
     process(rest, [], indent, options)
   end
 
   defp table_lines(lines, options) do
     lines = Enum.map(lines, &split_into_columns(&1, options))
-    count = Enum.map(lines, &length/1) |> Enum.max()
+    count = Enum.map(lines, &length/1) |> Enum.max
     lines = Enum.map(lines, &pad_to_number_of_columns(&1, count))
 
-    widths =
-      for line <- lines do
-        if table_header?(line) do
-          for _ <- line, do: 0
-        else
-          for {_col, length} <- line, do: length
-        end
-      end
+    widths = for line <- lines, do:
+              (for {_col, length} <- line, do: length)
+
+    col_widths = Enum.reduce(widths,
+                             List.duplicate(0, count),
+                             &max_column_widths/2)
 
-    col_widths = Enum.reduce(widths, List.duplicate(0, count), &max_column_widths/2)
     render_table(lines, col_widths, options)
   end
 
@@ -343,18 +287,15 @@ defmodule IO.ANSI.Docs do
     line
     |> String.trim("|")
     |> String.trim()
-    |> String.split(" | ")
+    |> String.split(~r/\s\|\s/)
     |> Enum.map(&render_column(&1, options))
   end
 
   defp render_column(col, options) do
-    col =
-      col
-      |> String.replace("\\\|", "|")
-      |> String.trim()
-      |> handle_links
-      |> handle_inline(options)
-
+    col = col
+          |> String.replace(~r/\\ \|/x, "|")
+          |> handle_links
+          |> handle_inline(options)
     {col, length_without_escape(col, 0)}
   end
 
@@ -367,10 +308,7 @@ defmodule IO.ANSI.Docs do
   # If second line is heading separator, use the heading style on the first
   defp render_table([first, second | rest], widths, options) do
     combined = Enum.zip(first, widths)
-
     if table_header?(second) do
-      alignments = Enum.map(second, &column_alignment/1)
-      options = Keyword.put_new(options, :alignments, alignments)
       draw_table_row(combined, options, :heading)
       render_table(rest, widths, options)
     else
@@ -385,65 +323,31 @@ defmodule IO.ANSI.Docs do
     render_table(rest, widths, options)
   end
 
-  defp render_table([], _, _), do: nil
+  defp render_table([], _, _),
+    do: nil
 
-  defp column_alignment({line, _}) do
-    cond do
-      String.starts_with?(line, ":") and String.ends_with?(line, ":") -> :center
-      String.ends_with?(line, ":") -> :right
-      true -> :left
-    end
-  end
-
-  defp table_header?(line) do
-    Enum.all?(line, fn {col, _} -> table_header_column?(col) end)
-  end
-
-  defp table_header_column?(":" <> rest), do: table_header_contents?(rest)
-  defp table_header_column?(col), do: table_header_contents?(col)
-
-  defp table_header_contents?("-" <> rest), do: table_header_contents?(rest)
-  defp table_header_contents?(":"), do: true
-  defp table_header_contents?(""), do: true
-  defp table_header_contents?(_), do: false
+  defp table_header?(row), do:
+    Enum.all?(row, fn {col, _} -> col =~ ~r/^:?-+:?$/ end)
 
   defp draw_table_row(cols_and_widths, options, heading \\ false) do
-    default_alignments = List.duplicate(:left, length(cols_and_widths))
-    alignments = Keyword.get(options, :alignments, default_alignments)
-
     columns =
-      cols_and_widths
-      |> Enum.zip(alignments)
-      |> Enum.map_join(" | ", &generate_table_cell/1)
+      Enum.map_join(cols_and_widths, " | ", fn {{col, length}, width} ->
+        col <> String.duplicate(" ", width - length)
+      end)
 
     if heading do
       write(:doc_table_heading, columns, options)
     else
-      IO.puts(columns)
+      IO.puts columns
     end
   end
 
-  defp generate_table_cell({{{col, length}, width}, :center}) do
-    ansi_diff = byte_size(col) - length
-    width = width + ansi_diff
-
-    col
-    |> String.pad_leading(div(width, 2) - div(length, 2) + length)
-    |> String.pad_trailing(width + 1 - rem(width, 2))
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :right}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_leading(col, width + ansi_diff)
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :left}) do
-    ansi_diff = byte_size(col) - length
-    String.pad_trailing(col, width + ansi_diff)
-  end
-
   defp table_line?(line) do
-    line =~ " | "
+    Regex.match?(~r'''
+      ( ^ \s{0,3} \| (?: [^|]+ \|)+ \s* $ )
+    |
+      (\s \| \s)
+    '''x, line)
   end
 
   ## Helpers
@@ -456,11 +360,13 @@ defmodule IO.ANSI.Docs do
   defp link_label?(""), do: false
   defp link_label?(<<_>> <> rest), do: link_label?(rest)
 
-  defp strip_spaces(" " <> line, acc, max) when acc < max, do: strip_spaces(line, acc + 1, max)
-  defp strip_spaces(rest, acc, _max), do: {rest, acc}
+  defp strip_spaces(" " <> line, acc, max) when acc < max,
+    do: strip_spaces(line, acc + 1, max)
+  defp strip_spaces(rest, acc, _max),
+    do: {rest, acc}
 
   defp write(style, string, options) do
-    IO.puts([color(style, options), string, IO.ANSI.reset()])
+    IO.puts [color(style, options), string, IO.ANSI.reset]
   end
 
   defp write_with_wrap([], _available, _indent, _first) do
@@ -469,7 +375,7 @@ defmodule IO.ANSI.Docs do
 
   defp write_with_wrap(words, available, indent, first) do
     {words, rest} = take_words(words, available, [])
-    IO.puts(if(first, do: "", else: indent) <> Enum.join(words, " "))
+    IO.puts (if first, do: "", else: indent) <> Enum.join(words, " ")
     write_with_wrap(rest, available, indent, false)
   end
 
@@ -517,17 +423,14 @@ defmodule IO.ANSI.Docs do
   end
 
   defp escape_underlines_in_link(text) do
-    ~r{https?\S*}
-    |> Regex.recompile!()
-    |> Regex.replace(text, &String.replace(&1, "_", "\\_"))
+    Regex.replace(~r{https?\S*}, text, &String.replace(&1, "_", "\\_"))
   end
 
   defp remove_square_brackets_in_link(text) do
-    ~r{\[(.*?)\]\((.*?)\)}
-    |> Regex.recompile!()
-    |> Regex.replace(text, "\\1 (\\2)")
+    Regex.replace(~r{\[(.*?)\]\((.*?)\)}, text, "\\1 (\\2)")
   end
 
+
   # We have four entries: **, *, _ and `.
   #
   # The first three behave the same while the last one is simpler
@@ -543,8 +446,7 @@ defmodule IO.ANSI.Docs do
 
   # Characters that can mark the beginning or the end of a word.
   # Only support the most common ones at this moment.
-  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&] ++
-                [?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
+  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&, ?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
 
   # Inline start
 
@@ -563,29 +465,29 @@ defmodule IO.ANSI.Docs do
   # Inline delimiters
 
   defp handle_inline(<<delimiter, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and delimiter in @delimiters do
+      when rest != "" and delimiter in @delimiters do
     handle_inline(rest, ?d, ["**"], [delimiter, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<delimiter, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and delimiter in @delimiters and mark in @single do
+      when rest != "" and delimiter in @delimiters and mark in @single do
     handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" do
+      when rest != "" do
     handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
   end
 
   # Clauses for handling escape
 
   defp handle_inline(<<?\\, ?\\, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" do
+      when rest != "" do
     handle_inline(rest, ?d, ["**"], [?\\, Enum.reverse(buffer) | acc], options)
   end
 
   defp handle_inline(<<?\\, ?\\, mark, rest::binary>>, nil, buffer, acc, options)
-       when rest != "" and mark in @single do
+      when rest != "" and mark in @single do
     handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer) | acc], options)
   end
 
@@ -595,31 +497,29 @@ defmodule IO.ANSI.Docs do
 
   # An escape is not valid inside `
   defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options)
-       when not (mark == limit and mark == ?`) do
+      when not(mark == limit and mark == ?`) do
     handle_inline(rest, limit, [mark | buffer], acc, options)
   end
 
   # Inline end
 
   defp handle_inline(<<?*, ?*, delimiter, rest::binary>>, ?d, buffer, acc, options)
-       when delimiter in @delimiters do
-    inline_buffer = inline_buffer(buffer, options)
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
+      when delimiter in @delimiters do
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<mark, delimiter, rest::binary>>, mark, buffer, acc, options)
-       when delimiter in @delimiters and mark in @single do
-    inline_buffer = inline_buffer(buffer, options)
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer | acc], options)
+      when delimiter in @delimiters and mark in @single do
+    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<?*, ?*, rest::binary>>, ?d, buffer, acc, options)
-       when rest == "" do
+      when rest == "" do
     handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
   defp handle_inline(<<mark, rest::binary>>, mark, buffer, acc, options)
-       when rest == "" and mark in @single do
+      when rest == "" and mark in @single do
     handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
   end
 
@@ -634,19 +534,19 @@ defmodule IO.ANSI.Docs do
   end
 
   defp handle_inline(<<>>, _mark, buffer, acc, _options) do
-    IO.iodata_to_binary(Enum.reverse([Enum.reverse(buffer) | acc]))
+    IO.iodata_to_binary Enum.reverse([Enum.reverse(buffer) | acc])
   end
 
   defp inline_buffer(buffer, options) do
-    [h | t] = Enum.reverse([IO.ANSI.reset() | buffer])
+    [h | t] = Enum.reverse([IO.ANSI.reset | buffer])
     [color_for(h, options) | t]
   end
 
   defp color_for(mark, colors) do
     case mark do
-      "`" -> color(:doc_inline_code, colors)
-      "_" -> color(:doc_underline, colors)
-      "*" -> color(:doc_bold, colors)
+      "`"  -> color(:doc_inline_code, colors)
+      "_"  -> color(:doc_underline, colors)
+      "*"  -> color(:doc_bold, colors)
       "**" -> color(:doc_bold, colors)
     end
   end
@@ -656,5 +556,5 @@ defmodule IO.ANSI.Docs do
     IO.ANSI.format_fragment(color, colors[:enabled])
   end
 
-  defp newline_after_block, do: IO.puts(IO.ANSI.reset())
+  defp newline_after_block, do: IO.puts(IO.ANSI.reset)
 end

lib/elixir/lib/io/stream.ex

@@ -1,9 +1,8 @@
 defmodule IO.StreamError do
   defexception [:reason, :message]
 
-  @impl true
   def exception(opts) do
-    reason = opts[:reason]
+    reason    = opts[:reason]
     formatted = IO.iodata_to_binary(:file.format_error(reason))
     %IO.StreamError{message: "error during streaming: #{formatted}", reason: reason}
   end
@@ -17,7 +16,7 @@ defmodule IO.Stream do
 
     * `device`        - the IO device
     * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given number of bytes
+    * `line_or_bytes` - if reading should read lines or a given amount of bytes
 
   It is worth noting that an IO stream has side effects and every time you go
   over the stream you may get different results.
@@ -42,12 +41,10 @@ defmodule IO.Stream do
       fn
         :ok, {:cont, x} ->
           case raw do
-            true -> IO.binwrite(device, x)
+            true  -> IO.binwrite(device, x)
             false -> IO.write(device, x)
           end
-
-        :ok, _ ->
-          stream
+        :ok, _ -> stream
       end
     end
   end
@@ -56,11 +53,10 @@ defmodule IO.Stream do
     def reduce(%{device: device, raw: raw, line_or_bytes: line_or_bytes}, acc, fun) do
       next_fun =
         case raw do
-          true -> &IO.each_binstream(&1, line_or_bytes)
+          true  -> &IO.each_binstream(&1, line_or_bytes)
           false -> &IO.each_stream(&1, line_or_bytes)
         end
-
-      Stream.resource(fn -> device end, next_fun, & &1).(acc, fun)
+      Stream.resource(fn -> device end, next_fun, &(&1)).(acc, fun)
     end
 
     def count(_stream) do
@@ -70,9 +66,5 @@ defmodule IO.Stream do
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    def slice(_stream) do
-      {:error, __MODULE__}
-    end
   end
 end

lib/elixir/lib/kernel/cli.ex

@@ -1,17 +1,9 @@
 defmodule Kernel.CLI do
   @moduledoc false
 
-  @blank_config %{
-    commands: [],
-    output: ".",
-    compile: [],
-    halt: true,
-    compiler_options: [],
-    errors: [],
-    pa: [],
-    pz: [],
-    verbose_compile: false
-  }
+  @blank_config %{commands: [], output: ".", compile: [],
+                  halt: true, compiler_options: [], errors: [],
+                  pa: [], pz: [], verbose_compile: false}
 
   @doc """
   This is the API invoked by Elixir boot process.
@@ -22,16 +14,14 @@ defmodule Kernel.CLI do
     {config, argv} = parse_argv(argv)
     System.argv(argv)
 
-    fun = fn _ ->
+    run fn _ ->
       errors = process_commands(config)
 
       if errors != [] do
         Enum.each(errors, &IO.puts(:stderr, &1))
         System.halt(1)
       end
-    end
-
-    run(fun, config.halt)
+    end, config.halt
   end
 
   @doc """
@@ -44,7 +34,6 @@ defmodule Kernel.CLI do
   """
   def run(fun, halt \\ true) do
     {ok_or_shutdown, status} = exec_fun(fun, {:ok, 0})
-
     if ok_or_shutdown == :shutdown or halt do
       {_, status} = at_exit({ok_or_shutdown, status})
 
@@ -66,28 +55,10 @@ defmodule Kernel.CLI do
   @doc false
   def process_commands(config) do
     results = Enum.map(Enum.reverse(config.commands), &process_command(&1, config))
-    errors = for {:error, msg} <- results, do: msg
+    errors  = for {:error, msg} <- results, do: msg
     Enum.reverse(config.errors, errors)
   end
 
-  @doc false
-  def format_error(kind, reason, stacktrace) do
-    {blamed, stacktrace} = Exception.blame(kind, reason, stacktrace)
-
-    iodata =
-      case blamed do
-        %FunctionClauseError{} ->
-          formatted = Exception.format_banner(kind, reason, stacktrace)
-          padded_blame = pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/2))
-          [formatted, padded_blame]
-
-        _ ->
-          Exception.format_banner(kind, blamed, stacktrace)
-      end
-
-    [iodata, ?\n, Exception.format_stacktrace(prune_stacktrace(stacktrace))]
-  end
-
   ## Helpers
 
   defp at_exit(res) do
@@ -105,23 +76,22 @@ defmodule Kernel.CLI do
           fun.(elem(res, 1))
         catch
           :exit, {:shutdown, int} when is_integer(int) ->
-            send(parent, {self(), {:shutdown, int}})
+            send parent, {self, {:shutdown, int}}
             exit({:shutdown, int})
-
           :exit, reason
-          when reason == :normal
-          when reason == :shutdown
-          when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
-            send(parent, {self(), {:shutdown, 0}})
+              when reason == :normal
+              when reason == :shutdown
+              when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
+            send parent, {self, {:shutdown, 0}}
             exit(reason)
-
           kind, reason ->
-            print_error(kind, reason, __STACKTRACE__)
-            send(parent, {self(), {:shutdown, 1}})
-            exit(to_exit(kind, reason, __STACKTRACE__))
+            stack = System.stacktrace
+            print_error(kind, reason, stack)
+            send parent, {self, {:shutdown, 1}}
+            exit(to_exit(kind, reason, stack))
         else
           _ ->
-            send(parent, {self(), res})
+            send parent, {self, res}
         end
       end)
 
@@ -129,7 +99,6 @@ defmodule Kernel.CLI do
       {^pid, res} ->
         :erlang.demonitor(ref, [:flush])
         res
-
       {:DOWN, ^ref, _, _, other} ->
         print_error({:EXIT, pid}, other, [])
         {:shutdown, 1}
@@ -145,39 +114,18 @@ defmodule Kernel.CLI do
       {[h | hs], _} when h == hd(list) ->
         new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
         callback.(hs, new_config)
-
       {new_list, new_config} ->
         callback.(new_list, new_config)
     end
   end
 
-  ## Error handling
-
-  defp print_error(kind, reason, stacktrace) do
-    IO.write(:stderr, format_error(kind, reason, stacktrace))
+  defp print_error(kind, reason, trace) do
+    IO.puts :stderr, Exception.format(kind, reason, prune_stacktrace(trace))
   end
 
-  defp blame_match(%{match?: true, node: node}, _), do: blame_ansi(:normal, "+", node)
-  defp blame_match(%{match?: false, node: node}, _), do: blame_ansi(:red, "-", node)
-  defp blame_match(_, string), do: string
-
-  defp blame_ansi(color, no_ansi, node) do
-    if IO.ANSI.enabled?() do
-      [color | Macro.to_string(node)]
-      |> IO.ANSI.format(true)
-      |> IO.iodata_to_binary()
-    else
-      no_ansi <> Macro.to_string(node) <> no_ansi
-    end
-  end
-
-  defp pad(string) do
-    "    " <> String.replace(string, "\n", "\n    ")
-  end
-
-  @elixir_internals [:elixir, :elixir_aliases, :elixir_expand, :elixir_compiler, :elixir_module] ++
-                      [:elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map] ++
-                      [:elixir_erl, :elixir_erl_clauses, :elixir_erl_pass, Kernel.ErrorHandler]
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
+                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
+                     :elixir_def, :elixir_map]
 
   defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
     prune_stacktrace(t)
@@ -198,59 +146,54 @@ defmodule Kernel.CLI do
   # Parse shared options
 
   defp parse_shared([opt | _t], _config) when opt in ["-v", "--version"] do
-    if function_exported?(IEx, :started?, 0) and IEx.started?() do
-      IO.puts("IEx " <> System.build_info()[:build])
+    if function_exported?(IEx, :started?, 0) and IEx.started? do
+      IO.puts "IEx " <> System.build_info[:build]
     else
-      IO.puts(:erlang.system_info(:system_version))
-      IO.puts("Elixir " <> System.build_info()[:build])
+      IO.puts :erlang.system_info(:system_version)
+      IO.puts "Elixir " <> System.build_info[:build]
     end
 
-    System.halt(0)
+    System.halt 0
   end
 
   defp parse_shared(["-pa", h | t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_patha/1)
-    parse_shared(t, %{config | pa: config.pa ++ paths})
+    parse_shared t, %{config | pa: config.pa ++ paths}
   end
 
   defp parse_shared(["-pz", h | t], config) do
     paths = expand_code_path(h)
     Enum.each(paths, &:code.add_pathz/1)
-    parse_shared(t, %{config | pz: config.pz ++ paths})
+    parse_shared t, %{config | pz: config.pz ++ paths}
   end
 
   defp parse_shared(["--app", h | t], config) do
-    parse_shared(t, %{config | commands: [{:app, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:app, h} | config.commands]}
   end
 
   defp parse_shared(["--no-halt" | t], config) do
-    parse_shared(t, %{config | halt: false})
+    parse_shared t, %{config | halt: false}
   end
 
   defp parse_shared(["-e", h | t], config) do
-    parse_shared(t, %{config | commands: [{:eval, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:eval, h} | config.commands]}
   end
 
   defp parse_shared(["-r", h | t], config) do
-    parse_shared(t, %{config | commands: [{:require, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:require, h} | config.commands]}
   end
 
   defp parse_shared(["-pr", h | t], config) do
-    parse_shared(t, %{config | commands: [{:parallel_require, h} | config.commands]})
+    parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
   end
 
-  @erl_arg_options ["--erl", "--sname", "--name", "--cookie"] ++
-                     ["--logger-otp-reports", "--logger-sasl-reports"]
-
-  @erl_boolean_options ["--detached", "--hidden", "--werl"]
-
-  defp parse_shared([erl, _ | t], config) when erl in @erl_arg_options do
-    parse_shared(t, config)
+  defp parse_shared([erl, _ | t], config) when erl in ["--erl", "--sname", "--name", "--cookie", "--logger-otp-reports", "--logger-sasl-reports"] do
+    parse_shared t, config
   end
 
-  defp parse_shared([erl | t], config) when erl in @erl_boolean_options do
-    parse_shared(t, config)
+  defp parse_shared([erl | t], config) when erl in ["--detached", "--hidden", "--werl"] do
+    parse_shared t, config
   end
 
   defp parse_shared(list, config) do
@@ -259,9 +202,8 @@ defmodule Kernel.CLI do
 
   defp expand_code_path(path) do
     path = Path.expand(path)
-
     case Path.wildcard(path) do
-      [] -> [to_charlist(path)]
+      []   -> [to_charlist(path)]
       list -> Enum.map(list, &to_charlist/1)
     end
   end
@@ -273,11 +215,11 @@ defmodule Kernel.CLI do
   end
 
   defp parse_argv(["+elixirc" | t], config) do
-    parse_compiler(t, config)
+    parse_compiler t, config
   end
 
   defp parse_argv(["+iex" | t], config) do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_argv(["-S", h | t], config) do
@@ -287,8 +229,7 @@ defmodule Kernel.CLI do
   defp parse_argv([h | t] = list, config) do
     case h do
       "-" <> _ ->
-        shared_option?(list, config, &parse_argv(&1, &2))
-
+        shared_option? list, config, &parse_argv(&1, &2)
       _ ->
         if Keyword.has_key?(config.commands, :eval) do
           {config, list}
@@ -309,40 +250,36 @@ defmodule Kernel.CLI do
   end
 
   defp parse_compiler(["-o", h | t], config) do
-    parse_compiler(t, %{config | output: h})
+    parse_compiler t, %{config | output: h}
   end
 
   defp parse_compiler(["--no-docs" | t], config) do
-    parse_compiler(t, %{config | compiler_options: [{:docs, false} | config.compiler_options]})
+    parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
   end
 
   defp parse_compiler(["--no-debug-info" | t], config) do
-    compiler_options = [{:debug_info, false} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:debug_info, false} | config.compiler_options]}
   end
 
   defp parse_compiler(["--ignore-module-conflict" | t], config) do
-    compiler_options = [{:ignore_module_conflict, true} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
   end
 
   defp parse_compiler(["--warnings-as-errors" | t], config) do
-    compiler_options = [{:warnings_as_errors, true} | config.compiler_options]
-    parse_compiler(t, %{config | compiler_options: compiler_options})
+    parse_compiler t, %{config | compiler_options: [{:warnings_as_errors, true} | config.compiler_options]}
   end
 
   defp parse_compiler(["--verbose" | t], config) do
-    parse_compiler(t, %{config | verbose_compile: true})
+    parse_compiler t, %{config | verbose_compile: true}
   end
 
   defp parse_compiler([h | t] = list, config) do
     case h do
       "-" <> _ ->
-        shared_option?(list, config, &parse_compiler(&1, &2))
-
+        shared_option? list, config, &parse_compiler(&1, &2)
       _ ->
         pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
-        parse_compiler(t, %{config | compile: [pattern | config.compile]})
+        parse_compiler t, %{config | compile: [pattern | config.compile]}
     end
   end
 
@@ -359,11 +296,11 @@ defmodule Kernel.CLI do
   # This clause is here so that Kernel.CLI does not
   # error out with "unknown option"
   defp parse_iex(["--dot-iex", _ | t], config) do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
-    parse_iex(t, config)
+    parse_iex t, config
   end
 
   defp parse_iex(["-S", h | t], config) do
@@ -372,8 +309,10 @@ defmodule Kernel.CLI do
 
   defp parse_iex([h | t] = list, config) do
     case h do
-      "-" <> _ -> shared_option?(list, config, &parse_iex(&1, &2))
-      _ -> {%{config | commands: [{:file, h} | config.commands]}, t}
+      "-" <> _ ->
+        shared_option? list, config, &parse_iex(&1, &2)
+      _ ->
+        {%{config | commands: [{:file, h} | config.commands]}, t}
     end
   end
 
@@ -384,23 +323,22 @@ defmodule Kernel.CLI do
   # Process commands
 
   defp process_command({:cookie, h}, _config) do
-    if Node.alive?() do
-      wrapper(fn -> Node.set_cookie(String.to_atom(h)) end)
+    if Node.alive? do
+      wrapper fn -> Node.set_cookie(String.to_atom(h)) end
     else
       {:error, "--cookie : Cannot set cookie if the node is not alive (set --name or --sname)"}
     end
   end
 
   defp process_command({:eval, expr}, _config) when is_binary(expr) do
-    wrapper(fn -> Code.eval_string(expr, []) end)
+    wrapper fn -> Code.eval_string(expr, []) end
   end
 
   defp process_command({:app, app}, _config) when is_binary(app) do
     case Application.ensure_all_started(String.to_atom(app)) do
       {:error, {app, reason}} ->
-        msg = "--app : Could not start application #{app}: " <> Application.format_error(reason)
-        {:error, msg}
-
+        {:error, "--app : Could not start application #{app}: " <>
+          Application.format_error(reason)}
       {:ok, _} ->
         :ok
     end
@@ -408,7 +346,7 @@ defmodule Kernel.CLI do
 
   defp process_command({:script, file}, _config) when is_binary(file) do
     if exec = find_elixir_executable(file) do
-      wrapper(fn -> Code.require_file(exec) end)
+      wrapper fn -> Code.require_file(exec) end
     else
       {:error, "-S : Could not find executable #{file}"}
     end
@@ -416,7 +354,7 @@ defmodule Kernel.CLI do
 
   defp process_command({:file, file}, _config) when is_binary(file) do
     if File.regular?(file) do
-      wrapper(fn -> Code.require_file(file) end)
+      wrapper fn -> Code.require_file(file) end
     else
       {:error, "No file named #{file}"}
     end
@@ -426,7 +364,7 @@ defmodule Kernel.CLI do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper(fn -> Enum.map(files, &Code.require_file(&1)) end)
+      wrapper fn -> Enum.map files, &Code.require_file(&1) end
     else
       {:error, "-r : No files matched pattern #{pattern}"}
     end
@@ -436,12 +374,7 @@ defmodule Kernel.CLI do
     files = filter_patterns(pattern)
 
     if files != [] do
-      wrapper(fn ->
-        case Kernel.ParallelCompiler.require(files) do
-          {:ok, _, _} -> :ok
-          {:error, _, _} -> exit({:shutdown, 1})
-        end
-      end)
+      wrapper fn -> Kernel.ParallelRequire.files(files) end
     else
       {:error, "-pr : No files matched pattern #{pattern}"}
     end
@@ -454,24 +387,17 @@ defmodule Kernel.CLI do
     case filter_multiple_patterns(patterns) do
       {:ok, []} ->
         {:error, "No files matched provided patterns"}
-
       {:ok, files} ->
-        wrapper(fn ->
+        wrapper fn ->
           Code.compiler_options(config.compiler_options)
-
           opts =
             if config.verbose_compile do
-              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 15s)")]
+              [each_long_compilation: &IO.puts("Compiling #{&1} (it's taking more than 5s)")]
             else
               []
             end
-
-          case Kernel.ParallelCompiler.compile_to_path(files, config.output, opts) do
-            {:ok, _, _} -> :ok
-            {:error, _, _} -> exit({:shutdown, 1})
-          end
-        end)
-
+          Kernel.ParallelCompiler.files_to_path(files, config.output, opts)
+        end
       {:missing, missing} ->
         {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
     end
@@ -479,23 +405,31 @@ defmodule Kernel.CLI do
 
   defp filter_patterns(pattern) do
     pattern
-    |> Path.wildcard()
-    |> :lists.usort()
+    |> Path.wildcard
+    |> :lists.usort
     |> Enum.filter(&File.regular?/1)
   end
 
   defp filter_multiple_patterns(patterns) do
-    {files, missing} =
-      Enum.reduce(patterns, {[], []}, fn pattern, {files, missing} ->
-        case filter_patterns(pattern) do
-          [] -> {files, [pattern | missing]}
-          match -> {match ++ files, missing}
-        end
-      end)
+    matched_files = Enum.map patterns, fn(pattern) ->
+      case filter_patterns(pattern) do
+        []    -> {:missing, pattern}
+        files -> {:ok, files}
+      end
+    end
 
-    case missing do
-      [] -> {:ok, :lists.usort(files)}
-      _ -> {:missing, :lists.usort(missing)}
+    files = Enum.filter_map matched_files,
+       fn(match) -> elem(match, 0) == :ok end,
+       &elem(&1, 1)
+
+    missing_patterns = Enum.filter_map matched_files,
+       fn(match) -> elem(match, 0) == :missing end,
+       &elem(&1, 1)
+
+    if missing_patterns == [] do
+      {:ok, :lists.usort(Enum.concat(files))}
+    else
+      {:missing, :lists.usort(missing_patterns)}
     end
   end
 
@@ -513,7 +447,6 @@ defmodule Kernel.CLI do
         {:win32, _} ->
           base = Path.rootname(exec)
           if File.regular?(base), do: base, else: exec
-
         _ ->
           exec
       end

lib/elixir/lib/kernel/error_handler.ex

@@ -3,19 +3,16 @@
 defmodule Kernel.ErrorHandler do
   @moduledoc false
 
-  @spec undefined_function(module, atom, list) :: term
   def undefined_function(module, fun, args) do
     ensure_loaded(module) or ensure_compiled(module, :module)
     :error_handler.undefined_function(module, fun, args)
   end
 
-  @spec undefined_lambda(module, fun, list) :: term
   def undefined_lambda(module, fun, args) do
     ensure_loaded(module) or ensure_compiled(module, :module)
     :error_handler.undefined_lambda(module, fun, args)
   end
 
-  @spec ensure_loaded(module) :: boolean
   def ensure_loaded(module) do
     case :code.ensure_loaded(module) do
       {:module, _} -> true
@@ -23,20 +20,17 @@ defmodule Kernel.ErrorHandler do
     end
   end
 
-  @spec ensure_compiled(module, atom) :: boolean
   # Never wait on nil because it should never be defined.
   def ensure_compiled(nil, _kind) do
     false
   end
-
   def ensure_compiled(module, kind) do
     parent = :erlang.get(:elixir_compiler_pid)
-    ref = :erlang.make_ref()
-    send(parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()})
-    :erlang.garbage_collect(self())
-
+    ref    = :erlang.make_ref
+    send parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()}
+    :erlang.garbage_collect(self)
     receive do
-      {^ref, :found} -> true
+      {^ref, :found}     -> true
       {^ref, :not_found} -> false
     end
   end

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -1,12 +1,11 @@
-# This is an Elixir module responsible for tracking references
-# to modules, remote dispatches, and the usage of
-# aliases/imports/requires in the Elixir scope.
+# This is an Elixir module responsible for tracking
+# the usage of aliases, imports and requires in the Elixir scope.
 #
 # Note that since this is required for bootstrap, we can't use
 # any of the `GenServer.Behaviour` conveniences.
 defmodule Kernel.LexicalTracker do
   @moduledoc false
-  @timeout 30000
+  @timeout 30_000
   @behaviour :gen_server
 
   @doc """
@@ -23,19 +22,27 @@ defmodule Kernel.LexicalTracker do
     :gen_server.call(to_pid(arg), :remote_dispatches, @timeout)
   end
 
-  defp to_pid(pid) when is_pid(pid), do: pid
+  @doc """
+  Gets the destination the lexical scope is meant to
+  compile to.
+  """
+  def dest(arg) do
+    :gen_server.call(to_pid(arg), :dest, @timeout)
+  end
 
+  defp to_pid(pid) when is_pid(pid),  do: pid
   defp to_pid(mod) when is_atom(mod) do
-    {set, _} = :elixir_module.data_tables(mod)
-    :ets.lookup_element(set, {:elixir, :lexical_tracker}, 2)
+    table = :elixir_module.data_table(mod)
+    [{_, val}] = :ets.lookup(table, {:elixir, :lexical_tracker})
+    val
   end
 
   # Internal API
 
-  # Starts the tracker and returns its PID.
+  # Starts the tracker and returns its pid.
   @doc false
-  def start_link() do
-    :gen_server.start_link(__MODULE__, :ok, [])
+  def start_link(dest) do
+    :gen_server.start_link(__MODULE__, dest, [])
   end
 
   @doc false
@@ -44,62 +51,35 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def add_import(pid, module, fas, line, warn) when is_atom(module) do
+  def add_import(pid, module, fas, line, warn) do
     :gen_server.cast(pid, {:add_import, module, fas, line, warn})
   end
 
   @doc false
-  def add_alias(pid, module, line, warn) when is_atom(module) do
+  def add_alias(pid, module, line, warn) do
     :gen_server.cast(pid, {:add_alias, module, line, warn})
   end
 
   @doc false
-  def remote_reference(pid, module, mode) when is_atom(module) do
+  def remote_reference(pid, module, mode) do
     :gen_server.cast(pid, {:remote_reference, module, mode})
   end
 
   @doc false
-  def remote_dispatch(pid, module, fa, line, mode) when is_atom(module) do
+  def remote_dispatch(pid, module, fa, line, mode) do
     :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
   end
 
   @doc false
-  def remote_struct(pid, module, line) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_struct, module, line})
-  end
-
-  @doc false
-  def import_dispatch(pid, module, fa, line, mode) when is_atom(module) do
+  def import_dispatch(pid, module, fa, line, mode) do
     :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
   end
 
   @doc false
-  def alias_dispatch(pid, module) when is_atom(module) do
+  def alias_dispatch(pid, module) do
     :gen_server.cast(pid, {:alias_dispatch, module})
   end
 
-  @doc false
-  def set_file(pid, file) do
-    :gen_server.cast(pid, {:set_file, file})
-  end
-
-  @doc false
-  def reset_file(pid) do
-    :gen_server.cast(pid, :reset_file)
-  end
-
-  @doc false
-  def write_cache(pid, value) do
-    key = :erlang.unique_integer()
-    :gen_server.cast(pid, {:write_cache, key, value})
-    key
-  end
-
-  @doc false
-  def read_cache(pid, key) do
-    :gen_server.call(pid, {:read_cache, key}, @timeout)
-  end
-
   @doc false
   def collect_unused_imports(pid) do
     unused(pid, :import)
@@ -116,57 +96,37 @@ defmodule Kernel.LexicalTracker do
 
   # Callbacks
 
-  def init(:ok) do
-    state = %{
-      directives: %{},
-      references: %{},
-      compile: %{},
-      runtime: %{},
-      structs: %{},
-      cache: %{},
-      file: nil
-    }
-
-    {:ok, state}
+  def init(dest) do
+    {:ok, %{directives: %{}, references: %{}, compile: %{},
+            runtime: %{}, dest: dest}}
   end
 
   @doc false
   def handle_call({:unused, tag}, _from, state) do
     directives =
-      for {{^tag, module_or_mfa}, marker} <- state.directives, is_integer(marker) do
-        {module_or_mfa, marker}
-      end
+      for {{^tag, module_or_mfa}, marker} <- state.directives,
+          is_integer(marker),
+          do: {module_or_mfa, marker}
 
     {:reply, Enum.sort(directives), state}
   end
 
   def handle_call(:remote_references, _from, state) do
-    {compile, runtime} = partition(:maps.to_list(state.references), [], [])
-    {:reply, {compile, :maps.keys(state.structs), runtime}, state}
+    {:reply, partition(Enum.to_list(state.references), [], []), state}
   end
 
   def handle_call(:remote_dispatches, _from, state) do
     {:reply, {state.compile, state.runtime}, state}
   end
 
-  def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
-    {:reply, :maps.get(key, cache), state}
-  end
-
-  def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
-    {:noreply, %{state | cache: :maps.put(key, value, cache)}}
+  def handle_call(:dest, _from, state) do
+    {:reply, state.dest, state}
   end
 
   def handle_cast({:remote_reference, module, mode}, state) do
     {:noreply, %{state | references: add_reference(state.references, module, mode)}}
   end
 
-  def handle_cast({:remote_struct, module, line}, state) do
-    state = add_remote_dispatch(state, module, {:__struct__, 1}, line, :compile)
-    structs = :maps.put(module, true, state.structs)
-    {:noreply, %{state | structs: structs}}
-  end
-
   def handle_cast({:remote_dispatch, module, fa, line, mode}, state) do
     references = add_reference(state.references, module, mode)
     state = add_remote_dispatch(state, module, fa, line, mode)
@@ -186,25 +146,19 @@ defmodule Kernel.LexicalTracker do
     {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
   end
 
-  def handle_cast({:set_file, file}, state) do
-    {:noreply, %{state | file: file}}
-  end
-
-  def handle_cast(:reset_file, state) do
-    {:noreply, %{state | file: nil}}
-  end
-
-  def handle_cast({:add_import, module, fas, line, warn}, state) do
+  def handle_cast({:add_import, module, fas, line, warn}, state) when is_atom(module) do
     directives =
-      state.directives
-      |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
-      |> :maps.from_list()
-      |> add_directive(module, line, warn, :import)
+      for {{:import, {import_module, _, _}}, _} = directive <- state.directives,
+          module != import_module,
+          do: directive,
+          into: %{}
+
+    directives = add_directive(directives, module, line, warn, :import)
 
     directives =
-      Enum.reduce(fas, directives, fn {function, arity}, directives ->
+      Enum.reduce fas, directives, fn {function, arity}, directives ->
         add_directive(directives, {module, function, arity}, line, warn, :import)
-      end)
+      end
 
     {:noreply, %{state | directives: directives}}
   end
@@ -234,42 +188,30 @@ defmodule Kernel.LexicalTracker do
 
   defp partition([{remote, :compile} | t], compile, runtime),
     do: partition(t, [remote | compile], runtime)
-
   defp partition([{remote, :runtime} | t], compile, runtime),
     do: partition(t, compile, [remote | runtime])
-
-  defp partition([], compile, runtime), do: {compile, runtime}
+  defp partition([], compile, runtime),
+    do: {compile, runtime}
 
   # Callbacks helpers
 
+  defp add_reference(references, module, :runtime) when is_atom(module),
+    do: map_put_new(module, :runtime, references)
   defp add_reference(references, module, :compile) when is_atom(module),
     do: :maps.put(module, :compile, references)
 
-  defp add_reference(references, module, :runtime) when is_atom(module) do
-    case :maps.find(module, references) do
-      {:ok, _} -> references
-      :error -> :maps.put(module, :runtime, references)
+  defp add_remote_dispatch(state, module, fa, line, mode) when is_atom(module) do
+    map_update mode, %{module => %{fa => [line]}}, state, fn mode_dispatches ->
+      map_update module, %{fa => [line]}, mode_dispatches, fn module_dispatches ->
+        map_update fa, [line], module_dispatches, &[line | List.delete(&1, line)]
+      end
     end
   end
 
-  defp add_remote_dispatch(state, module, fa, line, mode) when is_atom(module) do
-    location = location(state.file, line)
-
-    map_update(mode, %{module => %{fa => [location]}}, state, fn mode_dispatches ->
-      map_update(module, %{fa => [location]}, mode_dispatches, fn module_dispatches ->
-        map_update(fa, [location], module_dispatches, &[location | List.delete(&1, location)])
-      end)
-    end)
-  end
-
-  defp location(nil, line), do: line
-  defp location(file, line), do: {file, line}
-
   defp add_import_dispatch(state, module, function, arity) do
     directives =
       add_dispatch(state.directives, module, :import)
       |> add_dispatch({module, function, arity}, :import)
-
     # Always compile time because we depend
     # on the module at compile time
     references = add_reference(state.references, module, :compile)
@@ -295,4 +237,11 @@ defmodule Kernel.LexicalTracker do
       :error -> :maps.put(key, initial, map)
     end
   end
+
+  defp map_put_new(key, value, map) do
+    case :maps.find(key, map) do
+      {:ok, _} -> map
+      :error -> :maps.put(key, value, map)
+    end
+  end
 end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -1,40 +1,8 @@
 defmodule Kernel.ParallelCompiler do
   @moduledoc """
-  A module responsible for compiling and requiring files in parallel.
+  A module responsible for compiling files in parallel.
   """
 
-  @doc """
-  Starts a task for parallel compilation.
-
-  If you have a file that needs to compile other modules in parallel,
-  the spawned processes need to be aware of the compiler environment.
-  This function allows a developer to create a task that is aware of
-  those environments.
-
-  See `Task.async/1` for more information. The task spawned must be
-  always awaited on by calling `Task.await/1`
-  """
-  @doc since: "1.6.0"
-  def async(fun) when is_function(fun) do
-    if parent = :erlang.get(:elixir_compiler_pid) do
-      file = :erlang.get(:elixir_compiler_file)
-      dest = :erlang.get(:elixir_compiler_dest)
-      {:error_handler, error_handler} = :erlang.process_info(self(), :error_handler)
-
-      Task.async(fn ->
-        :erlang.put(:elixir_compiler_pid, parent)
-        :erlang.put(:elixir_compiler_file, file)
-        dest != :undefined and :erlang.put(:elixir_compiler_dest, dest)
-        :erlang.process_flag(:error_handler, error_handler)
-        fun.()
-      end)
-    else
-      raise ArgumentError,
-            "cannot spawn parallel compiler task because " <>
-              "the current file is not being compiled/required"
-    end
-  end
-
   @doc """
   Compiles the given files.
 
@@ -43,12 +11,11 @@ defmodule Kernel.ParallelCompiler do
   the current file stops being compiled until the dependency is
   resolved.
 
-  It returns `{:ok, modules, warnings}` or `{:error, errors, warnings}`.
+  If there is an error during compilation or if `warnings_as_errors`
+  is set to `true` and there is a warning, this function will fail
+  with an exception.
 
-  Both errors and warnings are a list of three element tuples containing
-  the file, line and the formatted error/warning.
-
-  ## Options
+  This function accepts the following options:
 
     * `:each_file` - for each file compiled, invokes the callback passing the
       file
@@ -57,239 +24,151 @@ defmodule Kernel.ParallelCompiler do
       timeout (see the `:long_compilation_threshold` option) to compile, invoke
       this callback passing the file as its argument
 
+    * `:long_compilation_threshold` - the timeout (in seconds) after the
+      `:each_long_compilation` callback is invoked; defaults to `10`
+
     * `:each_module` - for each module compiled, invokes the callback passing
       the file, module and the module bytecode
 
-    * `:each_cycle` - after the given files are compiled, invokes this function
-      that return a list with potentially more files to compile
-
-    * `:long_compilation_threshold` - the timeout (in seconds) after the
-      `:each_long_compilation` callback is invoked; defaults to `15`
-
-    * `:dest` - the destination directory for the BEAM files. When using `files/2`,
-      this information is only used to properly annotate the BEAM files before
+    * `:dest` - the destination directory for the beam files. When using `files/2`,
+      this information is only used to properly annotate the beam files before
       they are loaded into memory. If you want a file to actually be written to
-      `dest`, use `compile_to_path/3` instead.
+      `dest`, use `files_to_path/3` instead.
 
+  Returns the modules generated by each compiled file.
   """
-  @doc since: "1.6.0"
-  def compile(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :compile, options)
-  end
+  def files(files, options \\ [])
 
-  @doc since: "1.6.0"
-  def compile_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
-    spawn_workers(files, {:compile, path}, options)
+  def files(files, options) when is_list(options) do
+    spawn_compilers(files, nil, options)
   end
 
   @doc """
-  Requires the given files in parallel.
-
-  Opposite to compile, dependencies are not attempted to be
-  automatically solved between files.
-
-  It returns `{:ok, modules, warnings}` or `{:error, errors, warnings}`.
-
-  Both errors and warnings are a list of three element tuples containing
-  the file, line and the formatted error/warning.
-
-  ## Options
-
-    * `:each_file` - for each file compiled, invokes the callback passing the
-      file
-
-    * `:each_module` - for each module compiled, invokes the callback passing
-      the file, module and the module bytecode
-
+  Compiles the given files to the given path.
+  Read `files/2` for more information.
   """
-  @doc since: "1.6.0"
-  def require(files, options \\ []) when is_list(options) do
-    spawn_workers(files, :require, options)
+  def files_to_path(files, path, options \\ [])
+
+  def files_to_path(files, path, options) when is_binary(path) and is_list(options) do
+    spawn_compilers(files, path, options)
   end
 
-  # TODO: Deprecate on Elixir v1.8
-  @doc false
-  def files(files, options \\ []) when is_list(options) do
-    case spawn_workers(files, :compile, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
-    end
-  end
-
-  # TODO: Deprecate on Elixir v1.8
-  @doc false
-  def files_to_path(files, path, options \\ []) when is_binary(path) and is_list(options) do
-    case spawn_workers(files, {:compile, path}, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
-    end
-  end
-
-  defp spawn_workers(files, output, options) do
-    {:module, _} = :code.ensure_loaded(Kernel.ErrorHandler)
+  defp spawn_compilers(files, path, options) do
+    true = Code.ensure_loaded?(Kernel.ErrorHandler)
     compiler_pid = self()
     :elixir_code_server.cast({:reset_warnings, compiler_pid})
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
 
-    result =
-      spawn_workers(files, [], [], [], [], %{
-        dest: Keyword.get(options, :dest),
-        each_cycle: Keyword.get(options, :each_cycle, fn -> [] end),
-        each_file: Keyword.get(options, :each_file, fn _file -> :ok end),
-        each_long_compilation: Keyword.get(options, :each_long_compilation, fn _file -> :ok end),
-        each_module: Keyword.get(options, :each_module, fn _file, _module, _binary -> :ok end),
-        output: output,
-        long_compilation_threshold: Keyword.get(options, :long_compilation_threshold, 15),
-        schedulers: schedulers
-      })
+    result = spawn_compilers(%{
+      entries: files,
+      original: files,
+      output: path,
+      options: options,
+      waiting: [],
+      queued: [],
+      schedulers: schedulers,
+      result: [],
+    })
 
     # In case --warning-as-errors is enabled and there was a warning,
     # compilation status will be set to error.
-    compilation_status = :elixir_code_server.call({:compilation_status, compiler_pid})
-
-    case {result, compilation_status} do
-      {{:ok, _, warnings}, :error} ->
-        message = "Compilation failed due to warnings while using the --warnings-as-errors option"
-        IO.puts(:stderr, message)
-        {:error, warnings, []}
-
-      {{:error, errors, warnings}, :error} ->
-        {:error, errors ++ warnings, []}
-
-      _ ->
+    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
+      :ok ->
         result
+      :error ->
+        IO.puts :stderr, "Compilation failed due to warnings while using the --warnings-as-errors option"
+        exit({:shutdown, 1})
     end
   end
 
   # We already have n=schedulers currently running, don't spawn new ones
-  defp spawn_workers(files, waiting, queued, result, warnings, %{schedulers: schedulers} = state)
-       when length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(files, waiting, queued, result, warnings, state)
+  defp spawn_compilers(%{queued: queued, waiting: waiting, schedulers: schedulers} = state)
+      when length(queued) - length(waiting) >= schedulers do
+    wait_for_messages(state)
   end
 
   # Release waiting processes
-  defp spawn_workers([{ref, found} | t], waiting, queued, result, warnings, state) do
+  defp spawn_compilers(%{entries: [{ref, found} | t], waiting: waiting} = state) do
     waiting =
       case List.keytake(waiting, ref, 2) do
         {{_kind, pid, ^ref, _on, _defining}, waiting} ->
-          send(pid, {ref, found})
+          send pid, {ref, found}
           waiting
-
         nil ->
           waiting
       end
-
-    spawn_workers(t, waiting, queued, result, warnings, state)
+    spawn_compilers(%{state | entries: t, waiting: waiting})
   end
 
-  defp spawn_workers([file | files], waiting, queued, result, warnings, state) do
-    %{output: output, long_compilation_threshold: threshold, dest: dest} = state
+  defp spawn_compilers(%{entries: [file | files], queued: queued, output: output, options: options} = state) do
     parent = self()
 
     {pid, ref} =
-      :erlang.spawn_monitor(fn ->
+      :erlang.spawn_monitor fn ->
+        # Set the elixir_compiler_pid used by our custom Kernel.ErrorHandler.
         :erlang.put(:elixir_compiler_pid, parent)
-        :erlang.put(:elixir_compiler_file, file)
+        :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
 
-        result =
-          try do
-            _ =
-              case output do
-                {:compile, path} ->
-                  :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-                  :erlang.put(:elixir_compiler_dest, path)
-                  :elixir_compiler.file_to_path(Path.expand(file), path)
-
-                :compile ->
-                  :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-                  :erlang.put(:elixir_compiler_dest, dest)
-                  Code.compile_file(file)
-
-                :require ->
-                  Code.require_file(file)
-              end
-
-            :ok
-          catch
-            kind, reason ->
-              {kind, reason, __STACKTRACE__}
+        exit(try do
+          _ = if output do
+            :elixir_compiler.file_to_path(file, output)
+          else
+            :elixir_compiler.file(file, Keyword.get(options, :dest))
           end
+          {:shutdown, file}
+        catch
+          kind, reason ->
+            {:failure, kind, reason, System.stacktrace}
+        end)
+      end
 
-        send(parent, {:file_done, self(), file, result})
-        exit(:shutdown)
-      end)
+    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
+    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
 
-    timer_ref = Process.send_after(self(), {:timed_out, pid}, threshold * 1000)
-    queued = [{pid, ref, file, timer_ref} | queued]
-    spawn_workers(files, waiting, queued, result, warnings, state)
+    new_queued = [{pid, ref, file, timer_ref} | queued]
+    spawn_compilers(%{state | entries: files, queued: new_queued})
   end
 
-  # No more files, nothing waiting, queue is empty, this cycle is done
-  defp spawn_workers([], [], [], result, warnings, state) do
-    case state.each_cycle.() do
-      [] ->
-        modules = for {:module, mod} <- result, do: mod
-        warnings = Enum.reverse(warnings)
-        {:ok, modules, warnings}
-
-      more ->
-        spawn_workers(more, [], [], result, warnings, state)
-    end
+  # No more files, nothing waiting, queue is empty, we are done
+  defp spawn_compilers(%{entries: [], waiting: [], queued: [], result: result}) do
+    for {:module, mod} <- result, do: mod
   end
 
   # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-
-  # Single entry, just release it.
-  defp spawn_workers([], [_] = waiting, [_] = queued, result, warnings, state) do
-    [{_, _, ref, _, _}] = waiting
-    spawn_workers([{ref, :not_found}], waiting, queued, result, warnings, state)
-  end
-
-  # Multiple entries, try to release modules.
-  defp spawn_workers([], waiting, queued, result, warnings, state)
-       when length(waiting) == length(queued) do
-    # The goal of this function is to find leaves in the dependency graph,
-    # i.e. to find code that depends on code that we know is not being defined.
-    # Note we only release modules because those can be rescued. A missing
-    # struct is a guaranteed compile error, so we never release it and treat
-    # it exclusively a missing entry/deadlock.
-    pending =
-      for {pid, _, _, _} <- queued,
-          entry = waiting_on_without_definition(waiting, pid),
-          {kind, _, ref, on, _} = entry,
-          kind == :module,
-          do: {on, {ref, :not_found}}
+  defp spawn_compilers(%{entries: [], waiting: waiting, queued: queued} = state) when length(waiting) == length(queued) do
+    entries = for {pid, _, _, _} <- queued,
+                  entry = waiting_on_without_definition(waiting, pid),
+                  {_, _, ref, on, _} = entry,
+                  do: {on, {ref, :not_found}}
 
     # Instead of releasing all files at once, we release them in groups
     # based on the module they are waiting on. We pick the module being
     # depended on with less edges, as it is the mostly likely source of
-    # error (for example, someone made a typo). This may not always be
-    # true though. For example, if there is a macro injecting code into
+    # error (for example, someone made a type). This may not always be
+    # true though: for example, if there is a macro injecting code into
     # multiple modules and such code becomes faulty, now multiple modules
     # are waiting on the same module required by the faulty code. However,
     # since we need to pick something to be first, the one with fewer edges
     # sounds like a sane choice.
-    pending
-    |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
-    |> Enum.sort_by(&length(elem(&1, 1)))
-    |> case do
-      [{_on, refs} | _] ->
-        spawn_workers(refs, waiting, queued, result, warnings, state)
+    entries =
+      entries
+      |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
+      |> Enum.sort_by(&length(elem(&1, 1)))
+      |> Enum.find_value([], &elem(&1, 1))
 
-      [] ->
-        errors = handle_deadlock(waiting, queued)
-        {:error, errors, warnings}
+    case entries do
+      [] -> handle_deadlock(waiting, queued)
+      _  -> spawn_compilers(%{state | entries: entries})
     end
   end
 
   # No more files, but queue and waiting are not full or do not match
-  defp spawn_workers([], waiting, queued, result, warnings, state) do
-    wait_for_messages([], waiting, queued, result, warnings, state)
+  defp spawn_compilers(%{entries: []} = state) do
+    wait_for_messages(state)
   end
 
   defp waiting_on_without_definition(waiting, pid) do
     {_, ^pid, _, on, _} = entry = List.keyfind(waiting, pid, 1)
-
     if Enum.any?(waiting, fn {_, _, _, _, defining} -> on in defining end) do
       nil
     else
@@ -298,117 +177,72 @@ defmodule Kernel.ParallelCompiler do
   end
 
   # Wait for messages from child processes
-  defp wait_for_messages(files, waiting, queued, result, warnings, state) do
-    %{output: output} = state
+  defp wait_for_messages(state) do
+    %{entries: entries, options: options, waiting: waiting, queued: queued, result: result} = state
 
     receive do
       {:struct_available, module} ->
-        available =
-          for {:struct, _, ref, waiting_module, _defining} <- waiting,
-              module == waiting_module,
-              do: {ref, :found}
+        available = for {:struct, _, ref, waiting_module, _defining} <- waiting,
+                        module == waiting_module,
+                        do: {ref, :found}
 
-        result = [{:struct, module} | result]
-        spawn_workers(available ++ files, waiting, queued, result, warnings, state)
+        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
 
       {:module_available, child, ref, file, module, binary} ->
-        state.each_module.(file, module, binary)
+        if callback = Keyword.get(options, :each_module) do
+          callback.(file, module, binary)
+        end
 
         # Release the module loader which is waiting for an ack
-        send(child, {ref, :ack})
+        send child, {ref, :ack}
 
-        available =
-          for {:module, _, ref, waiting_module, _defining} <- waiting,
-              module == waiting_module,
-              do: {ref, :found}
+        available = for {:module, _, ref, waiting_module, _defining} <- waiting,
+                        module == waiting_module,
+                        do: {ref, :found}
 
         cancel_waiting_timer(queued, child)
 
-        result = [{:module, module} | result]
-        spawn_workers(available ++ files, waiting, queued, result, warnings, state)
-
-      # If we are simply requiring files, we do not add to waiting.
-      {:waiting, _kind, child, ref, _on, _defining} when output == :require ->
-        send(child, {ref, :not_found})
-        spawn_workers(files, waiting, queued, result, warnings, state)
+        spawn_compilers(%{state | entries: available ++ entries, result: [{:module, module} | result]})
 
       {:waiting, kind, child, ref, on, defining} ->
         # Oops, we already got it, do not put it on waiting.
-        # Alternatively, we're waiting on ourselves,
-        # send :found so that we can crash with a better error.
         waiting =
-          if :lists.any(&match?({^kind, ^on}, &1), result) or on in defining do
-            send(child, {ref, :found})
+          if :lists.any(&match?({^kind, ^on}, &1), result) do
+            send child, {ref, :found}
             waiting
           else
             [{kind, child, ref, on, defining} | waiting]
           end
 
-        spawn_workers(files, waiting, queued, result, warnings, state)
+        spawn_compilers(%{state | waiting: waiting})
 
       {:timed_out, child} ->
+        callback = Keyword.get(options, :each_long_compilation)
         case List.keyfind(queued, child, 0) do
-          {^child, _, file, _} ->
-            state.each_long_compilation.(file)
-
+          {^child, _, file, _} when not is_nil(callback) ->
+            callback.(file)
           _ ->
             :ok
         end
+        spawn_compilers(state)
 
-        spawn_workers(files, waiting, queued, result, warnings, state)
+      {:DOWN, _down_ref, :process, down_pid, {:shutdown, file}} ->
+        if callback = Keyword.get(options, :each_file) do
+          callback.(file)
+        end
 
-      {:warning, file, line, message} ->
-        file = file && Path.absname(file)
-        message = :unicode.characters_to_binary(message)
-        warning = {file, line, message}
-        wait_for_messages(files, waiting, queued, result, [warning | warnings], state)
-
-      {:file_done, child_pid, file, :ok} ->
-        discard_down(child_pid)
-        state.each_file.(file)
-        cancel_waiting_timer(queued, child_pid)
+        cancel_waiting_timer(queued, down_pid)
 
         # Sometimes we may have spurious entries in the waiting
         # list because someone invoked try/rescue UndefinedFunctionError
-        new_files = List.delete(files, child_pid)
-        new_queued = List.keydelete(queued, child_pid, 0)
-        new_waiting = List.keydelete(waiting, child_pid, 1)
-        spawn_workers(new_files, new_waiting, new_queued, result, warnings, state)
+        new_entries = List.delete(entries, down_pid)
+        new_queued  = List.keydelete(queued, down_pid, 0)
+        new_waiting = List.keydelete(waiting, down_pid, 1)
+        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
 
-      {:file_done, child_pid, file, {kind, reason, stack}} ->
-        discard_down(child_pid)
-        print_error(file, kind, reason, stack)
-        cancel_waiting_timer(queued, child_pid)
-        terminate(queued)
-        {:error, [to_error(file, kind, reason, stack)], warnings}
-
-      {:DOWN, ref, :process, _pid, reason} ->
-        case handle_down(queued, ref, reason) do
-          :ok -> wait_for_messages(files, waiting, queued, result, warnings, state)
-          {:error, errors} -> {:error, errors, warnings}
-        end
-    end
-  end
-
-  defp discard_down(pid) do
-    receive do
-      {:DOWN, _, :process, ^pid, _} -> :ok
-    end
-  end
-
-  defp handle_down(_queued, _ref, :normal) do
-    :ok
-  end
-
-  defp handle_down(queued, ref, reason) do
-    case List.keyfind(queued, ref, 1) do
-      {_child, ^ref, file, _timer_ref} ->
-        print_error(file, :exit, reason, [])
-        terminate(queued)
-        {:error, [to_error(file, :exit, reason, [])]}
-
-      _ ->
-        :ok
+      {:DOWN, down_ref, :process, _down_pid, reason} ->
+        handle_failure(down_ref, reason, queued)
+        wait_for_messages(state)
     end
   end
 
@@ -418,48 +252,78 @@ defmodule Kernel.ParallelCompiler do
         {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
         Process.exit(pid, :kill)
 
-        {kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
-        description = "deadlocked waiting on #{kind} #{inspect(on)}"
-        error = CompileError.exception(description: description, file: nil, line: nil)
-        print_error(file, :error, error, stacktrace)
+        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
+        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
+                                       file: nil, line: nil)
+        print_failure(file, {:failure, :error, error, stacktrace})
 
-        {file, on, description}
+        {file, on}
       end
 
-    IO.puts("""
+    IO.puts """
 
     Compilation failed because of a deadlock between files.
     The following files depended on the following modules:
-    """)
+    """
 
     max =
       deadlock
-      |> Enum.map(&(&1 |> elem(0) |> String.length()))
-      |> Enum.max()
+      |> Enum.map(& &1 |> elem(0) |> String.length)
+      |> Enum.max
 
-    for {file, mod, _} <- deadlock do
-      IO.puts(["  ", String.pad_leading(file, max), " => " | inspect(mod)])
+    for {file, mod} <- deadlock do
+      IO.puts ["  ", String.pad_leading(file, max), " => " | inspect(mod)]
     end
 
-    IO.puts(
-      "\nEnsure there are no compile-time dependencies between those files " <>
-        "and that the modules they reference exist and are correctly named\n"
-    )
-
-    for {file, _, description} <- deadlock, do: {Path.absname(file), nil, description}
+    IO.puts ""
+    exit({:shutdown, 1})
   end
 
-  defp terminate(queued) do
-    for {pid, _, _, _} <- queued do
-      Process.exit(pid, :kill)
+  defp handle_failure(ref, reason, queued) do
+    if file = find_failure(ref, queued) do
+      print_failure(file, reason)
+      for {pid, _, _, _} <- queued do
+        Process.exit(pid, :kill)
+      end
+      exit({:shutdown, 1})
     end
   end
 
-  defp print_error(file, kind, reason, stack) do
-    IO.write([
-      "\n== Compilation error in file #{Path.relative_to_cwd(file)} ==\n",
-      Kernel.CLI.format_error(kind, reason, stack)
-    ])
+  defp find_failure(ref, queued) do
+    case List.keyfind(queued, ref, 1) do
+      {_child, ^ref, file, _timer_ref} -> file
+      _ -> nil
+    end
+  end
+
+  defp print_failure(_file, {:shutdown, _}) do
+    :ok
+  end
+
+  defp print_failure(file, {:failure, kind, reason, stacktrace}) do
+    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
+    IO.puts Exception.format(kind, reason, prune_stacktrace(stacktrace))
+  end
+
+  defp print_failure(file, reason) do
+    IO.puts "\n== Compilation error on file #{Path.relative_to_cwd(file)} =="
+    IO.puts Exception.format(:exit, reason, [])
+  end
+
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
+                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
+                     :elixir_def, :elixir_map, Kernel.ErrorHandler]
+
+  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+    prune_stacktrace(t)
+  end
+
+  defp prune_stacktrace([h | t]) do
+    [h | prune_stacktrace(t)]
+  end
+
+  defp prune_stacktrace([]) do
+    []
   end
 
   defp cancel_waiting_timer(queued, child_pid) do
@@ -473,36 +337,8 @@ defmodule Kernel.ParallelCompiler do
         after
           0 -> :ok
         end
-
       nil ->
         :ok
     end
   end
-
-  defp to_error(file, kind, reason, stack) do
-    line = get_line(file, reason, stack)
-    file = Path.absname(file)
-    message = :unicode.characters_to_binary(Kernel.CLI.format_error(kind, reason, stack))
-    {file, line, message}
-  end
-
-  defp get_line(_file, %{line: line}, _stack) when is_integer(line) and line > 0 do
-    line
-  end
-
-  defp get_line(file, :undef, [{_, _, _, []}, {_, _, _, info} | _]) do
-    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      Keyword.get(info, :line)
-    end
-  end
-
-  defp get_line(file, _reason, [{_, _, _, info} | _]) do
-    if Keyword.get(info, :file) == to_charlist(Path.relative_to_cwd(file)) do
-      Keyword.get(info, :line)
-    end
-  end
-
-  defp get_line(_, _, _) do
-    nil
-  end
 end

lib/elixir/lib/kernel/parallel_require.ex

@@ -1,17 +1,108 @@
 defmodule Kernel.ParallelRequire do
-  # TODO: Deprecate on Elixir v1.8
-  @moduledoc false
+  @moduledoc """
+  A module responsible for requiring files in parallel.
+  """
 
+  @doc """
+  Requires the given files.
+
+  A callback that will be invoked with each file, or a keyword list of `callbacks` can be provided:
+
+    * `:each_file` - invoked with each file
+
+    * `:each_module` - invoked with file, module name, and binary code
+
+  Returns the modules generated by each required file.
+  """
   def files(files, callbacks \\ [])
 
   def files(files, callback) when is_function(callback, 1) do
-    files(files, each_file: callback)
+    files(files, [each_file: callback])
   end
 
-  def files(files, options) when is_list(options) do
-    case Kernel.ParallelCompiler.require(files, options) do
-      {:ok, modules, _} -> modules
-      {:error, _, _} -> exit({:shutdown, 1})
+  def files(files, callbacks) when is_list(callbacks) do
+    compiler_pid = self()
+    :elixir_code_server.cast({:reset_warnings, compiler_pid})
+    schedulers = max(:erlang.system_info(:schedulers_online), 2)
+    result = spawn_requires(files, [], callbacks, schedulers, [])
+
+    # In case --warning-as-errors is enabled and there was a warning,
+    # compilation status will be set to error.
+    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
+      :ok ->
+        result
+      :error ->
+        IO.puts :stderr, "\nExecution failed due to warnings while using the --warnings-as-errors option"
+        exit({:shutdown, 1})
+    end
+  end
+
+  defp spawn_requires([], [], _callbacks, _schedulers, result), do: result
+
+  defp spawn_requires([], waiting, callbacks, schedulers, result) do
+    wait_for_messages([], waiting, callbacks, schedulers, result)
+  end
+
+  defp spawn_requires(files, waiting, callbacks, schedulers, result) when length(waiting) >= schedulers do
+    wait_for_messages(files, waiting, callbacks, schedulers, result)
+  end
+
+  defp spawn_requires([h | t], waiting, callbacks, schedulers, result) do
+    parent = self()
+    {pid, ref} = :erlang.spawn_monitor fn ->
+      :erlang.put(:elixir_compiler_pid, parent)
+
+      exit(try do
+        new = Code.require_file(h) || []
+        {:required, Enum.map(new, &elem(&1, 0)), h}
+      catch
+        kind, reason ->
+          {:failure, kind, reason, System.stacktrace}
+      end)
+    end
+
+    spawn_requires(t, [{pid, ref} | waiting], callbacks, schedulers, result)
+  end
+
+  defp wait_for_messages(files, waiting, callbacks, schedulers, result) do
+    receive do
+      {:DOWN, ref, :process, pid, status} ->
+        tuple = {pid, ref}
+        if tuple in waiting do
+          waiting = List.delete(waiting, tuple)
+
+          case status do
+            {:required, mods, file} ->
+              if each_file_callback = callbacks[:each_file] do
+                each_file_callback.(file)
+              end
+
+              spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
+
+            {:failure, kind, reason, stacktrace} ->
+              :erlang.raise(kind, reason, stacktrace)
+
+            other ->
+              :erlang.raise(:exit, other, [])
+          end
+        else
+          spawn_requires(files, waiting, callbacks, schedulers, result)
+        end
+
+      {:module_available, child, ref, file, module, binary} ->
+        if each_module_callback = callbacks[:each_module] do
+          each_module_callback.(file, module, binary)
+        end
+
+        send(child, {ref, :ack})
+        spawn_requires(files, waiting, callbacks, schedulers, result)
+
+      {:struct_available, _} ->
+        spawn_requires(files, waiting, callbacks, schedulers, result)
+
+      {:waiting, _, child, ref, _, _} ->
+        send(child, {ref, :not_found})
+        spawn_requires(files, waiting, callbacks, schedulers, result)
     end
   end
 end

lib/elixir/lib/kernel/special_forms.ex

@@ -4,14 +4,16 @@ defmodule Kernel.SpecialForms do
   cannot be overridden by the developer.
 
   We define them in this module. Some of these forms are lexical (like
-  `alias/2`, `case/2`, etc). The macros `{}/1` and `<<>>/1` are also special
+  `alias/2`, `case/2`, etc). The macros `{}` and `<<>>` are also special
   forms used to define tuple and binary data structures respectively.
 
-  This module also documents macros that return information about Elixir's
-  compilation environment, such as (`__ENV__/0`, `__MODULE__/0`, `__DIR__/0` and `__CALLER__/0`).
+  This module also documents Elixir's pseudo variables (`__ENV__`,
+  `__MODULE__`, `__DIR__` and `__CALLER__`). Pseudo variables return
+  information about Elixir's compilation environment and can only
+  be read, never assigned to.
 
-  Finally, it also documents two special forms, `__block__/1` and
-  `__aliases__/1`, which are not intended to be called directly by the
+  Finally, it also documents two special forms, `__block__` and
+  `__aliases__`, which are not intended to be called directly by the
   developer but they appear in quoted contents since they are essential
   in Elixir's constructs.
   """
@@ -19,10 +21,7 @@ defmodule Kernel.SpecialForms do
   defmacrop error!(args) do
     quote do
       _ = unquote(args)
-
-      message =
-        "Elixir's special forms are expanded by the compiler and must not be invoked directly"
-
+      message = "Elixir's special forms are expanded by the compiler and must not be invoked directly"
       :erlang.error(RuntimeError.exception(message))
     end
   end
@@ -30,21 +29,19 @@ defmodule Kernel.SpecialForms do
   @doc """
   Creates a tuple.
 
-  More information about the tuple data type and about functions to manipulate
-  tuples can be found in the `Tuple` module; some functions for working with
-  tuples are also available in `Kernel` (such as `Kernel.elem/2` or
-  `Kernel.tuple_size/1`).
+  Only two item tuples are considered literals in Elixir.
+  Therefore all other tuples are represented in the AST
+  as a call to the special form `:{}`.
 
-  ## AST representation
+  Conveniences for manipulating tuples can be found in the
+  `Tuple` module. Some functions for working with tuples are
+  also available in `Kernel`, namely `Kernel.elem/2`,
+  `Kernel.put_elem/3` and `Kernel.tuple_size/1`.
 
-  Only two-item tuples are considered literals in Elixir and return themselves
-  when quoted. Therefore, all other tuples are represented in the AST as calls to
-  the `:{}` special form.
+  ## Examples
 
-      iex> quote do
-      ...>   {1, 2}
-      ...> end
-      {1, 2}
+      iex> {1, 2, 3}
+      {1, 2, 3}
 
       iex> quote do
       ...>   {1, 2, 3}
@@ -57,14 +54,56 @@ defmodule Kernel.SpecialForms do
   @doc """
   Creates a map.
 
-  See the `Map` module for more information about maps, their syntax, and ways to
-  access and manipulate them.
+  Maps are key-value stores where keys are compared
+  using the match operator (`===`). Maps can be created with
+  the `%{}` special form where keys are associated via `=>`:
+
+      %{1 => 2}
+
+  Maps also support the keyword notation, as other special forms,
+  as long as they are at the end of the argument list:
+
+      %{hello: :world, with: :keywords}
+      %{:hello => :world, with: :keywords}
+
+  If a map has duplicated keys, the last key will always have
+  higher precedence:
+
+      iex> %{a: :b, a: :c}
+      %{a: :c}
+
+  Conveniences for manipulating maps can be found in the
+  `Map` module.
+
+  ## Access syntax
+
+  Besides the access functions available in the `Map` module,
+  like `Map.get/3` and `Map.fetch/2`, a map can be accessed using the
+  `.` operator:
+
+      iex> map = %{a: :b}
+      iex> map.a
+      :b
+
+  Note that the `.` operator expects the key `:a` to exist in the map.
+  If not, an `ArgumentError` is raised.
+
+  ## Update syntax
+
+  Maps also support an update syntax:
+
+      iex> map = %{:a => :b}
+      iex> %{map | :a => :c}
+      %{:a => :c}
+
+  Notice the update syntax requires the given keys to exist.
+  Trying to update a key that does not exist will raise an `KeyError`.
 
   ## AST representation
 
-  Regardless of whether `=>` or the keyword syntax is used, key-value pairs in
-  maps are always represented internally as a list of two-element tuples for
-  simplicity:
+  Regardless if `=>` or the keywords syntax is used, Maps are
+  always represented internally as a list of two-element tuples
+  for simplicity:
 
       iex> quote do
       ...>   %{"a" => :b, c: :d}
@@ -75,7 +114,7 @@ defmodule Kernel.SpecialForms do
   defmacro unquote(:%{})(args), do: error!([args])
 
   @doc """
-  Matches on or builds a struct.
+  Creates a struct.
 
   A struct is a tagged map that allows developers to provide
   default values for keys, tags to be used in polymorphic
@@ -96,25 +135,16 @@ defmodule Kernel.SpecialForms do
 
       %User{} == %{__struct__: User, name: "john", age: 27}
 
-  The struct fields can be given when building the struct:
+  A struct also validates that the given keys are part of the defined
+  struct. The example below will fail because there is no key
+  `:full_name` in the `User` struct:
 
-      %User{age: 31}
-      #=> %{__struct__: User, name: "john", age: 31}
-
-  Or also on pattern matching to extract values out:
-
-      %User{age: age} = user
+      %User{full_name: "john doe"}
 
   An update operation specific for structs is also available:
 
       %User{user | age: 28}
 
-  The advantage of structs is that they validate that the given
-  keys are part of the defined struct. The example below will fail
-  because there is no key `:full_name` in the `User` struct:
-
-      %User{full_name: "john doe"}
-
   The syntax above will guarantee the given keys are valid at
   compilation time and it will guarantee at runtime the given
   argument is a struct, failing with `BadStructError` otherwise.
@@ -125,24 +155,6 @@ defmodule Kernel.SpecialForms do
   can be used with protocols for polymorphic dispatch. Also
   see `Kernel.struct/2` and `Kernel.struct!/2` for examples on
   how to create and update structs dynamically.
-
-  ## Pattern matching on struct names
-
-  Besides allowing pattern matching on struct fields, such as:
-
-      %User{age: age} = user
-
-  Structs also allow pattern matching on the struct name:
-
-      %struct_name{} = user
-      struct_name #=> User
-
-  You can also assign the struct name to `_` when you want to
-  check if something is a struct but you are not interested in
-  its name:
-
-      %_{} = user
-
   """
   defmacro unquote(:%)(struct, map), do: error!([struct, map])
 
@@ -161,10 +173,10 @@ defmodule Kernel.SpecialForms do
 
   - `integer`
   - `float`
-  - `bits` (alias for `bitstring`)
+  - `bits` (alias for bitstring)
   - `bitstring`
   - `binary`
-  - `bytes` (alias for `binary`)
+  - `bytes` (alias for binary)
   - `utf8`
   - `utf16`
   - `utf32`
@@ -186,13 +198,13 @@ defmodule Kernel.SpecialForms do
       iex> <<102, rest>>
       ** (ArgumentError) argument error
 
-  We can solve this by explicitly tagging it as `binary`:
+  We can solve this by explicitly tagging it as a binary:
 
       iex> rest = "oo"
       iex> <<102, rest::binary>>
       "foo"
 
-  The `utf8`, `utf16`, and `utf32` types are for Unicode codepoints. They
+  The utf8, utf16, and utf32 types are for Unicode codepoints. They
   can also be applied to literal strings and charlists:
 
       iex> <<"foo"::utf16>>
@@ -252,7 +264,7 @@ defmodule Kernel.SpecialForms do
       iex> x = 1
       iex> <<x::8>> == <<x::size(8)>>
       true
-      iex> <<x::8*4>> == <<x::size(8)-unit(4)>>
+      iex> <<x::8 * 4>> == <<x::size(8)-unit(4)>>
       true
 
   This syntax reflects the fact the effective size is given by
@@ -267,8 +279,8 @@ defmodule Kernel.SpecialForms do
   -------------------- | ----------------
   `signed`             | `integer`
   `unsigned` (default) | `integer`
-  `little`             | `integer`, `float`, `utf16`, `utf32`
-  `big` (default)      | `integer`, `float`, `utf16`, `utf32`
+  `little`             | `integer`, `utf16`, `utf32`
+  `big` (default)      | `integer`, `utf16`, `utf32`
   `native`             | `integer`, `utf16`, `utf32`
 
   ### Sign
@@ -321,9 +333,9 @@ defmodule Kernel.SpecialForms do
 
   Or as a part of function definitions to pattern match:
 
-      defmodule ImageTyper do
+      defmodule ImageTyper
         @png_signature <<137::size(8), 80::size(8), 78::size(8), 71::size(8),
-                         13::size(8), 10::size(8), 26::size(8), 10::size(8)>>
+                      13::size(8), 10::size(8), 26::size(8), 10::size(8)>>
         @jpg_signature <<255::size(8), 216::size(8)>>
 
         def type(<<@png_signature, rest::binary>>), do: :png
@@ -346,7 +358,7 @@ defmodule Kernel.SpecialForms do
   defmacro unquote(:<<>>)(args), do: error!([args])
 
   @doc """
-  Defines a remote call, a call to an anonymous function, or an alias.
+  Defines a remote call or an alias.
 
   The dot (`.`) in Elixir can be used for remote calls:
 
@@ -354,16 +366,8 @@ defmodule Kernel.SpecialForms do
       "foo"
 
   In this example above, we have used `.` to invoke `downcase` in the
-  `String` module, passing `"FOO"` as argument.
-
-  The dot may be used to invoke anonymous functions too:
-
-      iex> (fn n -> n end).(7)
-      7
-
-  in which case there is a function on the left hand side.
-
-  We can also use the dot for creating aliases:
+  `String` alias, passing "FOO" as argument. We can also use the dot
+  for creating aliases:
 
       iex> Hello.World
       Hello.World
@@ -387,20 +391,16 @@ defmodule Kernel.SpecialForms do
       iex> Kernel.+(1, 2)
       3
 
-      iex> Kernel."+"(1, 2)
+      iex> Kernel."length"([1, 2, 3])
       3
 
-  Note that wrapping the function name in single- or double-quotes is always a
-  remote call. Therefore `Kernel."Foo"` will attempt to call the function "Foo"
-  and not return the alias `Kernel.Foo`. This is done by design as module names
-  are more strict than function names.
+      iex> Kernel.'+'(1, 2)
+      3
 
-  When the dot is used to invoke an anonymous function there is only one
-  operand, but it is still written using a postfix notation:
-
-      iex> negate = fn n -> -n end
-      iex> negate.(7)
-      -7
+  Note that `Kernel."HELLO"` will be treated as a remote call and not an alias.
+  This choice was done so every time single- or double-quotes are used, we have
+  a remote call regardless of the quote contents. This decision is also reflected
+  in the quoted expressions discussed below.
 
   ## Quoted expression
 
@@ -420,18 +420,17 @@ defmodule Kernel.SpecialForms do
 
   This tuple follows the general quoted expression structure in Elixir,
   with the name as first argument, some keyword list as metadata as second,
-  and the list of arguments as third. In this case, the arguments are the
-  alias `String` and the atom `:downcase`. The second argument in a remote call
-  is **always** an atom.
-
-  In the case of calls to anonymous functions, the inner tuple with the dot
-  special form has only one argument, reflecting the fact that the operator is
-  unary:
+  and the number of arguments as third. In this case, the arguments is the
+  alias `String` and the atom `:downcase`. The second argument is **always**
+  an atom:
 
       iex> quote do
-      ...>   negate.(0)
+      ...>   String."downcase"("FOO")
       ...> end
-      {{:., [], [{:negate, [], __MODULE__}]}, [], [0]}
+      {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
+
+  The tuple containing `:.` is wrapped in another tuple, which actually
+  represents the function call, and has `"FOO"` as argument.
 
   When the right side is an alias (i.e. starts with uppercase), we get instead:
 
@@ -440,7 +439,7 @@ defmodule Kernel.SpecialForms do
       ...> end
       {:__aliases__, [alias: false], [:Hello, :World]}
 
-  We go into more details about aliases in the `__aliases__/1` special form
+  We go into more details about aliases in the `__aliases__` special form
   documentation.
 
   ## Unquoting
@@ -453,7 +452,7 @@ defmodule Kernel.SpecialForms do
       ...> end
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
-  Similar to `Kernel."FUNCTION_NAME"`, `unquote(x)` will always generate a remote call,
+  Similar to `Kernel."HELLO"`, `unquote(x)` will always generate a remote call,
   independent of the value of `x`. To generate an alias via the quoted expression,
   one needs to rely on `Module.concat/2`:
 
@@ -497,16 +496,6 @@ defmodule Kernel.SpecialForms do
 
       alias Foo.Bar.Baz, as: Baz
 
-  We can also alias multiple modules in one line:
-
-      alias Foo.{Bar, Baz, Biz}
-
-  Is the same as:
-
-      alias Foo.Bar
-      alias Foo.Baz
-      alias Foo.Biz
-
   ## Lexical scope
 
   `import/2`, `require/2` and `alias/2` are called directives and all
@@ -528,12 +517,13 @@ defmodule Kernel.SpecialForms do
   defmacro alias(module, opts), do: error!([module, opts])
 
   @doc """
-  Requires a module in order to use its macros.
+  Requires a given module to be compiled and loaded.
 
   ## Examples
 
-  Public functions in modules are globally available, but in order to use
-  macros, you need to opt-in by requiring the module they are defined in.
+  Notice that usually modules should not be required before usage,
+  the only exception is if you want to use the macros from a module.
+  In such cases, you need to explicitly require them.
 
   Let's suppose you created your own `if/2` implementation in the module
   `MyMacros`. If you want to invoke it, you need to first explicitly
@@ -591,9 +581,8 @@ defmodule Kernel.SpecialForms do
       import List, only: [flatten: 1]
       import String, except: [split: 2]
 
-  Notice that calling `except` is always exclusive on a previously
-  declared `import/2`. If there is no previous import, then it applies
-  to all functions and macros in the module. For example:
+  Notice that calling `except` for a previously declared `import/2`
+  simply filters the previously imported elements. For example:
 
       import List, only: [flatten: 1, keyfind: 4]
       import List, except: [flatten: 1]
@@ -665,7 +654,7 @@ defmodule Kernel.SpecialForms do
   @doc """
   Returns the current module name as an atom or `nil` otherwise.
 
-  Although the module can be accessed in the `__ENV__/0`, this macro
+  Although the module can be accessed in the `__ENV__`, this macro
   is a convenient shortcut.
   """
   defmacro __MODULE__, do: error!([])
@@ -686,14 +675,6 @@ defmodule Kernel.SpecialForms do
   """
   defmacro __CALLER__, do: error!([])
 
-  @doc """
-  Returns the stacktrace for the curently handled exception.
-
-  It is available only in the `catch` and `rescue` clauses of `try/1`
-  expressions.
-  """
-  defmacro __STACKTRACE__, do: error!([])
-
   @doc """
   Accesses an already bound variable in match clauses. Also known as the pin operator.
 
@@ -724,7 +705,7 @@ defmodule Kernel.SpecialForms do
       1
 
   """
-  defmacro ^var, do: error!([var])
+  defmacro ^(var), do: error!([var])
 
   @doc """
   Matches the value on the right against the pattern on the left.
@@ -791,8 +772,6 @@ defmodule Kernel.SpecialForms do
       quote. Read the Stacktrace information section below for more
       information.
 
-    * `:line` - sets the quoted expressions to have the given line.
-
     * `:generated` - marks the given chunk as generated so it does not emit warnings.
       Currently it only works on special forms (for example, you can annotate a `case`
       but not an `if`).
@@ -880,7 +859,7 @@ defmodule Kernel.SpecialForms do
         end
       end
 
-  Now invoking `squared(my_number.())` as before will print the value just
+  Now invoking `square(my_number.())` as before will print the value just
   once.
 
   In fact, this pattern is so common that most of the times you will want
@@ -896,7 +875,7 @@ defmodule Kernel.SpecialForms do
 
   `:bind_quoted` will translate to the same code as the example above.
   `:bind_quoted` can be used in many cases and is seen as good practice,
-  not only because it helps prevent us from running into common mistakes, but also
+  not only because it helps us from running into common mistakes but also
   because it allows us to leverage other tools exposed by macros, such as
   unquote fragments discussed in some sections below.
 
@@ -1090,8 +1069,8 @@ defmodule Kernel.SpecialForms do
 
       Hygiene.return_length #=> 3
 
-  Notice how `Hygiene.return_length/0` returns `3` even though the `Kernel.length/1`
-  function is not imported. In fact, even if `return_length/0`
+  Notice how `return_length` returns 3 even though the `length/1`
+  function is not imported. In fact, even if `return_length`
   imported a function with the same name and arity from another
   module, it wouldn't affect the function result:
 
@@ -1100,10 +1079,10 @@ defmodule Kernel.SpecialForms do
         get_length
       end
 
-  Calling this new `return_length/0` will still return `3` as result.
+  Calling this new `return_length` will still return 3 as result.
 
   Elixir is smart enough to delay the resolution to the latest
-  possible moment. So, if you call `length([1, 2, 3])` inside quote,
+  moment possible. So, if you call `length([1, 2, 3])` inside quote,
   but no `length/1` function is available, it is then expanded in
   the caller:
 
@@ -1294,7 +1273,7 @@ defmodule Kernel.SpecialForms do
       [2, 4, 6, 8]
 
       # A comprehension with two generators
-      iex> for x <- [1, 2], y <- [2, 3], do: x * y
+      iex> for x <- [1, 2], y <- [2, 3], do: x*y
       [2, 3, 4, 6]
 
   Filters can also be given:
@@ -1316,7 +1295,7 @@ defmodule Kernel.SpecialForms do
   need to organize bitstring streams:
 
       iex> pixels = <<213, 45, 132, 64, 76, 32, 76, 0, 0, 234, 32, 15>>
-      iex> for <<r::8, g::8, b::8 <- pixels>>, do: {r, g, b}
+      iex> for <<r::8, g::8, b::8 <- pixels >>, do: {r, g, b}
       [{213, 45, 132}, {64, 76, 32}, {76, 0, 0}, {234, 32, 15}]
 
   Variable assignments inside the comprehension, be it in generators,
@@ -1343,18 +1322,6 @@ defmodule Kernel.SpecialForms do
         String.upcase(line)
       end
 
-  ## Uniq
-
-  `uniq: true` can also be given to comprehensions to guarantee that
-  that results are only added to the collection if they were not returned
-  before. For example:
-
-      iex> for(x <- [1, 1, 2, 3], uniq: true, do: x * 2)
-      [2, 4, 6]
-
-      iex> for(<<x <- "abcabc">>, uniq: true, into: "", do: <<x - 32>>)
-      "ABC"
-
   """
   defmacro for(args), do: error!([args])
 
@@ -1365,9 +1332,8 @@ defmodule Kernel.SpecialForms do
 
       iex> opts = %{width: 10, height: 15}
       iex> with {:ok, width} <- Map.fetch(opts, :width),
-      ...>      {:ok, height} <- Map.fetch(opts, :height) do
-      ...>   {:ok, width * height}
-      ...> end
+      ...>      {:ok, height} <- Map.fetch(opts, :height),
+      ...>   do: {:ok, width * height}
       {:ok, 150}
 
   If all clauses match, the `do` block is executed, returning its result.
@@ -1375,17 +1341,15 @@ defmodule Kernel.SpecialForms do
 
       iex> opts = %{width: 10}
       iex> with {:ok, width} <- Map.fetch(opts, :width),
-      ...>      {:ok, height} <- Map.fetch(opts, :height) do
-      ...>   {:ok, width * height}
-      ...> end
+      ...>      {:ok, height} <- Map.fetch(opts, :height),
+      ...>   do: {:ok, width * height}
       :error
 
   Guards can be used in patterns as well:
 
       iex> users = %{"melany" => "guest", "bob" => :admin}
-      iex> with {:ok, role} when not is_binary(role) <- Map.fetch(users, "bob") do
-      ...>   {:ok, to_string(role)}
-      ...> end
+      iex> with {:ok, role} when not is_binary(role) <- Map.fetch(users, "bob"),
+      ...>   do: {:ok, to_string(role)}
       {:ok, "admin"}
 
   As in `for/1`, variables bound inside `with/1` won't leak;
@@ -1395,33 +1359,12 @@ defmodule Kernel.SpecialForms do
       iex> opts = %{width: 10, height: 15}
       iex> with {:ok, width} <- Map.fetch(opts, :width),
       ...>      double_width = width * 2,
-      ...>      {:ok, height} <- Map.fetch(opts, :height) do
-      ...>   {:ok, double_width * height}
-      ...> end
+      ...>      {:ok, height} <- Map.fetch(opts, :height),
+      ...>   do: {:ok, double_width * height}
       {:ok, 300}
       iex> width
       nil
 
-  Note that if a "bare expression" fails to match, it will raise a `MatchError`
-  instead of returning the non-matched value:
-
-      with :foo = :bar, do: :ok
-      #=> ** (MatchError) no match of right hand side value: :bar
-
-  As with any other function or macro call in Elixir, explicit parens can
-  also be used around the arguments before the `do`/`end` block:
-
-      iex> opts = %{width: 10, height: 15}
-      iex> with(
-      ...>   {:ok, width} <- Map.fetch(opts, :width),
-      ...>   {:ok, height} <- Map.fetch(opts, :height)
-      ...> ) do
-      ...>   {:ok, width * height}
-      ...> end
-      {:ok, 150}
-
-  The choice between parens and no parens is a matter of preference.
-
   An `else` option can be given to modify what is being returned from
   `with` in the case of a failed match:
 
@@ -1436,6 +1379,7 @@ defmodule Kernel.SpecialForms do
       {:error, :wrong_data}
 
   If there is no matching `else` condition, then a `WithClauseError` exception is raised.
+
   """
   defmacro with(args), do: error!([args])
 
@@ -1448,16 +1392,6 @@ defmodule Kernel.SpecialForms do
       iex> add.(1, 2)
       3
 
-  Anonymous functions can also have multiple clauses. All clauses
-  should expect the same number of arguments:
-
-      iex> negate = fn
-      ...>   true -> false
-      ...>   false -> true
-      ...> end
-      iex> negate.(false)
-      true
-
   """
   defmacro unquote(:fn)(clauses), do: error!([clauses])
 
@@ -1476,7 +1410,7 @@ defmodule Kernel.SpecialForms do
       {:__block__, [], [1, 2, 3]}
 
   """
-  defmacro unquote(:__block__)(args), do: error!([args])
+  defmacro __block__(args), do: error!([args])
 
   @doc """
   Captures or creates an anonymous function.
@@ -1512,18 +1446,11 @@ defmodule Kernel.SpecialForms do
       4
 
   In other words, `&(&1 * 2)` is equivalent to `fn x -> x * 2 end`.
+  Another example using a local function:
 
-  We can partially apply a remote function with placeholder:
-
-      iex> take_five = &Enum.take(&1, 5)
-      iex> take_five.(1..10)
-      [1, 2, 3, 4, 5]
-
-  Another example while using an imported or local function:
-
-      iex> first_elem = &elem(&1, 0)
-      iex> first_elem.({0, 1})
-      0
+      iex> fun = &is_atom(&1)
+      iex> fun.(:atom)
+      true
 
   The `&` operator can be used with more complex expressions:
 
@@ -1538,8 +1465,8 @@ defmodule Kernel.SpecialForms do
       {1, 2}
 
       iex> fun = &[&1 | &2]
-      iex> fun.(1, [2, 3])
-      [1, 2, 3]
+      iex> fun.(1, 2)
+      [1 | 2]
 
   The only restrictions when creating anonymous functions is that at
   least one placeholder must be present, i.e. it must contain at least
@@ -1586,7 +1513,7 @@ defmodule Kernel.SpecialForms do
     3. When the head element of aliases is the atom `:Elixir`, no expansion happens.
 
   """
-  defmacro unquote(:__aliases__)(args), do: error!([args])
+  defmacro __aliases__(args), do: error!([args])
 
   @doc """
   Calls the overridden function when overriding it with `Kernel.defoverridable/1`.
@@ -1698,7 +1625,7 @@ defmodule Kernel.SpecialForms do
   defmacro cond(clauses), do: error!([clauses])
 
   @doc ~S"""
-  Evaluates the given expressions and handles any error, exit,
+  Evaluates the given expressions and handles any error, exit
   or throw that may have happened.
 
   ## Examples
@@ -1710,86 +1637,77 @@ defmodule Kernel.SpecialForms do
           IO.puts "Invalid argument given"
       catch
         value ->
-          IO.puts "Caught #{inspect(value)}"
+          IO.puts "caught #{value}"
       else
         value ->
-          IO.puts "Success! The result was #{inspect(value)}"
+          IO.puts "Success! The result was #{value}"
       after
         IO.puts "This is printed regardless if it failed or succeed"
       end
 
-  The `rescue` clause is used to handle exceptions while the `catch`
-  clause can be used to catch thrown values and exits.
-  The `else` clause can be used to control flow based on the result of
-  the expression. `catch`, `rescue`, and `else` clauses work based on
-  pattern matching (similar to the `case` special form).
+  The rescue clause is used to handle exceptions, while the catch
+  clause can be used to catch thrown values. The else clause can
+  be used to control flow based on the result of the expression.
+  Catch, rescue and else clauses work based on pattern matching.
 
   Note that calls inside `try/1` are not tail recursive since the VM
-  needs to keep the stacktrace in case an exception happens. To
-  retrieve the stacktrace, access `__STACKTRACE__/0` inside the `rescue`
-  or `catch` clause.
+  needs to keep the stacktrace in case an exception happens.
 
-  ## `rescue` clauses
+  ## Rescue clauses
 
-  Besides relying on pattern matching, `rescue` clauses provide some
-  conveniences around exceptions that allow one to rescue an
-  exception by its name. All the following formats are valid patterns
-  in `rescue` clauses:
+  Besides relying on pattern matching, rescue clauses provides some
+  conveniences around exceptions that allows one to rescue an
+  exception by its name. All the following formats are valid rescue
+  expressions:
 
-      # Rescue a single exception without binding the exception
-      # to a variable
       try do
         UndefinedModule.undefined_function
       rescue
         UndefinedFunctionError -> nil
       end
 
-      # Rescue any of the given exception without binding
       try do
         UndefinedModule.undefined_function
       rescue
-        [UndefinedFunctionError, ArgumentError] -> nil
+        [UndefinedFunctionError] -> nil
       end
 
-      # Rescue and bind the exception to the variable "x"
+      # rescue and bind to x
       try do
         UndefinedModule.undefined_function
       rescue
         x in [UndefinedFunctionError] -> nil
       end
 
-      # Rescue all kinds of exceptions and bind the rescued exception
-      # to the variable "x"
+      # rescue all and bind to x
       try do
         UndefinedModule.undefined_function
       rescue
         x -> nil
       end
 
-  ### Erlang errors
+  ## Erlang errors
 
-  Erlang errors are transformed into Elixir ones when rescuing:
+  Erlang errors are transformed into Elixir ones during rescue:
 
       try do
         :erlang.error(:badarg)
       rescue
         ArgumentError -> :ok
       end
-      #=> :ok
 
   The most common Erlang errors will be transformed into their
-  Elixir counterpart. Those which are not will be transformed
-  into the more generic `ErlangError`:
+  Elixir counter-part. Those which are not will be transformed
+  into `ErlangError`:
 
       try do
         :erlang.error(:unknown)
       rescue
         ErlangError -> :ok
       end
-      #=> :ok
 
   In fact, `ErlangError` can be used to rescue any error that is
-  not a proper Elixir error. For example, it can be used to rescue
+  not an Elixir error proper. For example, it can be used to rescue
   the earlier `:badarg` error too, prior to transformation:
 
       try do
@@ -1797,63 +1715,35 @@ defmodule Kernel.SpecialForms do
       rescue
         ErlangError -> :ok
       end
-      #=> :ok
 
-  ## `catch` clauses
+  ## Catching throws and exits
 
-  The `catch` clause can be used to catch thrown values, exits, and errors.
-
-  ### Catching thrown values
-
-  `catch` can be used to catch values thrown by `Kernel.throw/1`:
-
-      try do
-        throw(:some_value)
-      catch
-        thrown_value ->
-          IO.puts "A value was thrown: #{inspect(thrown_value)}"
-      end
-
-  ### Catching values of any kind
-
-  The `catch` clause also supports catching exits and errors. To do that, it
-  allows matching on both the *kind* of the caught value as well as the value
-  itself:
+  The catch clause can be used to catch throws values and exits.
 
       try do
         exit(:shutdown)
       catch
-        :exit, value
-          IO.puts "Exited with value #{inspect(value)}"
+        :exit, :shutdown -> IO.puts "Exited with shutdown reason"
       end
 
       try do
-        exit(:shutdown)
+        throw(:sample)
       catch
-        kind, value when kind in [:exit, :throw] ->
-          IO.puts "Caught exit or throw with value #{inspect(value)}"
+        :throw, :sample ->
+          IO.puts "sample thrown"
       end
 
-  The `catch` clause also supports `:error` alongside `:exit` and `:throw` as
-  in Erlang, although this is commonly avoided in favor of `raise`/`rescue` control
-  mechanisms. One reason for this is that when catching `:error`, the error is
-  not automatically transformed into an Elixir error:
+  catch values also support `:error`, as in Erlang, although it is
+  commonly avoided in favor of raise/rescue control mechanisms.
 
-      try do
-        :erlang.error(:badarg)
-      catch
-        :error, :badarg -> :ok
-      end
-      #=> :ok
-
-  ## `after` clauses
+  ## After clauses
 
   An `after` clause allows you to define cleanup logic that will be invoked both
-  when the block of code passed to `try/1` succeeds and also when an error is raised. Note
-  that the process will exit as usual when receiving an exit signal that causes
+  when the tried block of code succeeds and also when an error is raised. Note
+  that the process will exit as usually when receiving an exit signal that causes
   it to exit abruptly and so the `after` clause is not guaranteed to be executed.
   Luckily, most resources in Elixir (such as open files, ETS tables, ports, sockets,
-  and so on) are linked to or monitor the owning process and will automatically clean
+  etc.) are linked to or monitor the owning process and will automatically clean
   themselves up if that process exits.
 
       File.write!("tmp/story.txt", "Hello, World")
@@ -1863,9 +1753,9 @@ defmodule Kernel.SpecialForms do
         File.rm("tmp/story.txt")
       end
 
-  ## `else` clauses
+  ## Else clauses
 
-  `else` clauses allow the result of the body passed to `try/1` to be pattern
+  Else clauses allow the result of the expression to be pattern
   matched on:
 
       x = 2
@@ -1881,7 +1771,7 @@ defmodule Kernel.SpecialForms do
           :large
       end
 
-  If an `else` clause is not present and no exceptions are raised,
+  If an else clause is not present and no exceptions are raised,
   the result of the expression will be returned:
 
       x = 1
@@ -1893,16 +1783,16 @@ defmodule Kernel.SpecialForms do
             :infinity
         end
 
-  However, when an `else` clause is present but the result of the expression
-  does not match any of the patterns then an exception will be raised. This
-  exception will not be caught by a `catch` or `rescue` in the same `try`:
+  However when an else clause is present but the result of the expression
+  does not match any of the patterns an exception will be raised. This
+  exception will not be caught by a catch or rescue in the same try:
 
       x = 1
       try do
         try do
           1 / x
         rescue
-          # The TryClauseError cannot be rescued here:
+          # The TryClauseError can not be rescued here:
           TryClauseError ->
             :error_a
         else
@@ -1915,8 +1805,8 @@ defmodule Kernel.SpecialForms do
           :error_b
       end
 
-  Similarly, an exception inside an `else` clause is not caught or rescued
-  inside the same `try`:
+  Similarly an exception inside an else clause is not caught or rescued
+  inside the same try:
 
       try do
         try do
@@ -1936,25 +1826,10 @@ defmodule Kernel.SpecialForms do
       end
 
   This means the VM no longer needs to keep the stacktrace once inside
-  an `else` clause and so tail recursion is possible when using a `try`
-  with a tail call as the final call inside an `else` clause. The same
+  an else clause and so tail recursion is possible when using a `try`
+  with a tail call as the final call inside an else clause. The same
   is true for `rescue` and `catch` clauses.
 
-  Only the result of the tried expression falls down to the `else` clause.
-  If the `try` ends up in the `rescue` or `catch` clauses, their result
-  will not fall down to `else`:
-
-      try do
-        throw(:catch_this)
-      catch
-        :throw, :catch_this ->
-          :it_was_caught
-      else
-        # :it_was_caught will not fall down to this "else" clause.
-        other ->
-          {:else, other}
-      end
-
   ## Variable handling
 
   Since an expression inside `try` may not have been evaluated
@@ -1997,22 +1872,22 @@ defmodule Kernel.SpecialForms do
   ## Examples
 
       receive do
-        {:selector, number, name} when is_integer(number) ->
-          name
-        name when is_atom(name) ->
-          name
+        {:selector, i, value} when is_integer(i) ->
+          value
+        value when is_atom(value) ->
+          value
         _ ->
           IO.puts :stderr, "Unexpected message received"
       end
 
   An optional `after` clause can be given in case the message was not
-  received after the given timeout period, specified in milliseconds:
+  received after the specified timeout period:
 
       receive do
-        {:selector, number, name} when is_integer(number) ->
-          name
-        name when is_atom(name) ->
-          name
+        {:selector, i, value} when is_integer(i) ->
+          value
+        value when is_atom(value) ->
+          value
         _ ->
           IO.puts :stderr, "Unexpected message received"
       after
@@ -2021,19 +1896,15 @@ defmodule Kernel.SpecialForms do
       end
 
   The `after` clause can be specified even if there are no match clauses.
-  The timeout value given to `after` can be any expression evaluating to
-  one of the allowed values:
+  The timeout value given to `after` can be a variable; two special
+  values are allowed:
 
     * `:infinity` - the process should wait indefinitely for a matching
-      message, this is the same as not using the after clause
+      message, this is the same as not using a timeout
 
     * `0` - if there is no matching message in the mailbox, the timeout
       will occur immediately
 
-    * positive integer smaller than or equal to `4_294_967_295` (`0xFFFFFFFF`
-      in hexadecimal notation) - it should be possible to represent the timeout
-      value as an unsigned 32-bit integer.
-
   ## Variables handling
 
   The `receive/1` special form handles variables exactly as the `case/2`

lib/elixir/lib/kernel/utils.ex

@@ -3,16 +3,8 @@ import Kernel, except: [destructure: 2, defdelegate: 2, defstruct: 2]
 defmodule Kernel.Utils do
   @moduledoc false
 
-  @doc """
-  Callback for destructure.
-  """
-  def destructure(list, count)
-      when is_list(list) and is_integer(count) and count >= 0,
-      do: destructure_list(list, count)
-
-  def destructure(nil, count)
-      when is_integer(count) and count >= 0,
-      do: destructure_nil(count)
+  def destructure(list, count) when is_list(list), do: destructure_list(list, count)
+  def destructure(nil, count), do: destructure_nil(count)
 
   defp destructure_list(_, 0), do: []
   defp destructure_list([], count), do: destructure_nil(count)
@@ -21,12 +13,8 @@ defmodule Kernel.Utils do
   defp destructure_nil(0), do: []
   defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
 
-  @doc """
-  Callback for defdelegate.
-  """
-  def defdelegate(fun, opts) when is_list(opts) do
-    # TODO: Remove by 2.0
-    append_first? = Keyword.get(opts, :append_first, false)
+  def defdelegate(fun, opts) do
+    append_first = Keyword.get(opts, :append_first, false)
 
     {name, args} =
       case Macro.decompose_call(fun) do
@@ -34,46 +22,49 @@ defmodule Kernel.Utils do
         _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
       end
 
+    as_args_list = normalize_args(args)
     as = Keyword.get(opts, :as, name)
-    as_args = build_as_args(args, append_first?)
-
-    {name, args, as, as_args}
+    :lists.map(fn as_args ->
+      formal_args = make_formal_args(as_args)
+      as_args = case append_first do
+        true  -> tl(as_args) ++ [hd(as_args)]
+        false -> as_args
+      end
+      {name, formal_args, as, as_args}
+    end, as_args_list)
   end
 
-  defp build_as_args(args, append_first?) do
-    as_args = :lists.map(&build_as_arg/1, args)
-
-    case append_first? do
-      true -> tl(as_args) ++ [hd(as_args)]
-      false -> as_args
-    end
+  defp make_formal_args(args) do
+    fun = &match?({name, _, mod} when is_atom(name) and is_atom(mod), &1)
+    :lists.filter(fun, args)
   end
 
-  defp build_as_arg({:\\, _, [arg, _default_arg]}), do: validate_arg(arg)
-  defp build_as_arg(arg), do: validate_arg(arg)
-
-  defp validate_arg({name, _, mod} = arg) when is_atom(name) and is_atom(mod) do
-    arg
+  defp normalize_args(raw_args) do
+    :lists.foldr(fn
+      ({:\\, _, [arg, default_arg]}, [as_args | _] = as_args_list) ->
+        new_as_args = [default_arg | as_args]
+        [new_as_args | add_arg(as_args_list, arg)]
+      (arg, as_args_list) ->
+        add_arg(as_args_list, arg)
+    end, [[]], raw_args)
   end
 
-  defp validate_arg(ast) do
+  defp add_arg(as_args_list, {name, _, mod} = arg) when is_atom(name) and is_atom(mod),
+    do: :lists.map(&([arg | &1]), as_args_list)
+  defp add_arg(_, code) do
     raise ArgumentError,
-          "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
+      "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(code)}"
   end
 
-  @doc """
-  Callback for defstruct.
-  """
   def defstruct(module, fields) do
     case fields do
       fs when is_list(fs) ->
         :ok
-
       other ->
-        raise ArgumentError, "struct fields definition must be list, got: #{inspect(other)}"
+        raise ArgumentError, "struct fields definition must be list, got: #{inspect other}"
     end
 
-    mapper = fn
+    fields = :lists.map(fn
       {key, val} when is_atom(key) ->
         try do
           Macro.escape(val)
@@ -83,186 +74,14 @@ defmodule Kernel.Utils do
         else
           _ -> {key, val}
         end
-
       key when is_atom(key) ->
         {key, nil}
-
       other ->
-        raise ArgumentError, "struct field names must be atoms, got: #{inspect(other)}"
-    end
+        raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
+    end, fields)
 
-    fields = :lists.map(mapper, fields)
-    enforce_keys = List.wrap(Module.get_attribute(module, :enforce_keys))
-
-    foreach = fn
-      key when is_atom(key) ->
-        :ok
-
-      key ->
-        raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect(key)}"
-    end
-
-    :lists.foreach(foreach, enforce_keys)
-
-    struct = :maps.put(:__struct__, module, :maps.from_list(fields))
-    {struct, enforce_keys, Module.get_attribute(module, :derive)}
-  end
-
-  @doc """
-  Announcing callback for defstruct.
-  """
-  def announce_struct(module) do
-    case :erlang.get(:elixir_compiler_pid) do
-      :undefined -> :ok
-      pid -> send(pid, {:struct_available, module})
-    end
-  end
-
-  @doc """
-  Callback for raise.
-  """
-  def raise(msg) when is_binary(msg) do
-    RuntimeError.exception(msg)
-  end
-
-  def raise(module) when is_atom(module) do
-    module.exception([])
-  end
-
-  def raise(%_{__exception__: true} = exception) do
-    exception
-  end
-
-  def raise(other) do
-    ArgumentError.exception(
-      "raise/1 and reraise/2 expect a module name, string or exception " <>
-        "as the first argument, got: #{inspect(other)}"
-    )
-  end
-
-  @doc """
-  Callback for defguard.
-
-  Rewrites an expression so it can be used both inside and outside a guard.
-
-  Take, for example, the expression:
-
-      is_integer(value) and rem(value, 2) == 0
-
-  If we wanted to create a macro, `is_even`, from this expression, that could be
-  used in guards, we'd have to take several things into account.
-
-  First, if this expression is being used inside a guard, `value` needs to be
-  unquoted each place it occurs, since it has not yet been at that point in our
-  macro.
-
-  Secondly, if the expression is being used outside of a guard, we want to unquote
-  `value`––but only once, and then re-use the unquoted form throughout the expression.
-
-  This helper does exactly that: takes the AST for an expression and a list of
-  variable references it should be aware of, and rewrites it into a new expression
-  that checks for its presence in a guard, then unquotes the variable references as
-  appropriate.
-
-  The resulting transformation looks something like this:
-
-      > expression = quote do: is_integer(value) and rem(value, 2) == 0
-      > variable_references = [value: Elixir]
-      > Kernel.Utils.defguard(expression, variable_references) |> Macro.to_string |> IO.puts
-
-      case Macro.Env.in_guard? __CALLER__ do
-        true -> quote do
-          is_integer(unquote(value)) and rem(unquote(value), 2) == 0
-        end
-        false -> quote do
-          value = unquote(value)
-          is_integer(value) and rem(value, 2) == 0
-        end
-      end
-
-  """
-  defmacro defguard(args, expr) do
-    defguard(args, expr, __CALLER__)
-  end
-
-  @spec defguard([Macro.t()], Macro.t(), Macro.Env.t()) :: Macro.t()
-  def defguard(args, expr, env) do
-    {^args, vars} = extract_refs_from_args(args)
-    env = :elixir_env.with_vars(%{env | context: :guard}, vars)
-    {expr, _scope} = :elixir_expand.expand(expr, env)
-
-    quote do
-      case Macro.Env.in_guard?(__CALLER__) do
-        true -> unquote(literal_quote(unquote_every_ref(expr, vars)))
-        false -> unquote(literal_quote(unquote_refs_once(expr, vars)))
-      end
-    end
-  end
-
-  defp extract_refs_from_args(args) do
-    Macro.postwalk(args, [], fn
-      {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
-        {var, [{ref, var_context(meta, context)} | acc]}
-
-      node, acc ->
-        {node, acc}
-    end)
-  end
-
-  # Finds every reference to `refs` in `guard` and wraps them in an unquote.
-  defp unquote_every_ref(guard, refs) do
-    Macro.postwalk(guard, fn
-      {ref, meta, context} = var when is_atom(ref) and is_atom(context) ->
-        case {ref, var_context(meta, context)} in refs do
-          true -> literal_unquote(var)
-          false -> var
-        end
-
-      node ->
-        node
-    end)
-  end
-
-  # Prefaces `guard` with unquoted versions of `refs`.
-  defp unquote_refs_once(guard, refs) do
-    {_, used_refs} =
-      Macro.postwalk(guard, [], fn
-        {ref, meta, context} = var, acc when is_atom(ref) and is_atom(context) ->
-          pair = {ref, var_context(meta, context)}
-
-          case pair in refs and pair not in acc do
-            true -> {var, [pair | acc]}
-            false -> {var, acc}
-          end
-
-        node, acc ->
-          {node, acc}
-      end)
-
-    vars = for {ref, context} <- :lists.reverse(used_refs), do: context_to_var(ref, context)
-    exprs = for var <- vars, do: literal_unquote(var)
-
-    quote do
-      {unquote_splicing(vars)} = {unquote_splicing(exprs)}
-      unquote(guard)
-    end
-  end
-
-  defp literal_quote(ast) do
-    {:quote, [], [[do: ast]]}
-  end
-
-  defp literal_unquote(ast) do
-    {:unquote, [], List.wrap(ast)}
-  end
-
-  defp context_to_var(ref, ctx) when is_atom(ctx), do: {ref, [], ctx}
-  defp context_to_var(ref, ctx) when is_integer(ctx), do: {ref, [counter: ctx], nil}
-
-  defp var_context(meta, kind) do
-    case :lists.keyfind(:counter, 1, meta) do
-      {:counter, counter} -> counter
-      false -> kind
-    end
+    {:maps.put(:__struct__, module, :maps.from_list(fields)),
+     List.wrap(Module.get_attribute(module, :enforce_keys)),
+     Module.get_attribute(module, :derive)}
   end
 end

lib/elixir/lib/keyword.ex

@@ -6,40 +6,6 @@ defmodule Keyword do
   element of the tuple is an atom and the second element
   can be any value.
 
-  For example, the following is a keyword list:
-
-      [{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]
-
-  Elixir provides a special and more concise syntax for keyword lists
-  that looks like this:
-
-      [exit_on_close: true, active: :once, packet_size: 1024]
-
-  This is also the syntax that Elixir uses to inspect keyword lists:
-
-      iex> [{:active, :once}]
-      [active: :once]
-
-  The two syntaxes are completely equivalent. If the keyword has foreign
-  characters, such as spaces, you can wrap it in quotes:
-
-      iex> ["exit on close": true]
-      ["exit on close": true]
-
-  Wrapping a keyword in quotes does not make it a string. Keywords are
-  always atoms and quotes should only be used to handle foreign characters.
-  In fact, if you attempt use quotes when not necessary, Elixir will warn.
-
-  Note that when keyword lists are passed as the last argument to a function,
-  if the short-hand syntax is used then the square brackets around the keyword list
-  can be omitted as well. For example, the following:
-
-      String.split("1-0", "-", trim: true, parts: 2)
-
-  is equivalent to:
-
-      String.split("1-0", "-", [trim: true, parts: 2])
-
   A keyword may have duplicated keys so it is not strictly
   a key-value store. However most of the functions in this module
   behave exactly as a dictionary so they work similarly to
@@ -49,10 +15,6 @@ defmodule Keyword do
   the given key, regardless if duplicated entries exist.
   Similarly, `Keyword.put/3` and `Keyword.delete/3` ensure all
   duplicated entries for a given key are removed when invoked.
-  Note that operations that require keys to be found in the keyword
-  list (like `Keyword.get/3`) need to traverse the list in order
-  to find keys, so these operations may be slower than their map
-  counterparts.
 
   A handful of functions exist to handle duplicated keys, in
   particular, `Enum.into/2` allows creating new keywords without
@@ -60,10 +22,10 @@ defmodule Keyword do
   a given key and `delete_first/2` deletes just one of the existing
   entries.
 
-  The functions in `Keyword` do not guarantee any property when
+  The functions in Keyword do not guarantee any property when
   it comes to ordering. However, since a keyword list is simply a
   list, all the operations defined in `Enum` and `List` can be
-  applied too, especially when ordering is required.
+  applied too, specially when ordering is required.
   """
 
   @compile :inline_list_funcs
@@ -97,7 +59,7 @@ defmodule Keyword do
   def keyword?(term)
 
   def keyword?([{key, _value} | rest]) when is_atom(key), do: keyword?(rest)
-  def keyword?([]), do: true
+  def keyword?([]),     do: true
   def keyword?(_other), do: false
 
   @doc """
@@ -128,7 +90,7 @@ defmodule Keyword do
       [a: 3]
 
   """
-  @spec new(Enum.t()) :: t
+  @spec new(Enum.t) :: t
   def new(pairs) do
     new(pairs, fn pair -> pair end)
   end
@@ -142,17 +104,16 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.new([:a, :b], fn x -> {x, x} end)
+      iex> Keyword.new([:a, :b], fn(x) -> {x, x} end)
       [a: :a, b: :b]
 
   """
-  @spec new(Enum.t(), (term -> {key, value})) :: t
+  @spec new(Enum.t, (term -> {key, value})) :: t
   def new(pairs, transform) do
     fun = fn el, acc ->
       {k, v} = transform.(el)
       put_new(acc, k, v)
     end
-
     :lists.foldl(fun, [], Enum.reverse(pairs))
   end
 
@@ -184,6 +145,7 @@ defmodule Keyword do
       3
 
   """
+  @spec get(t, key) :: value
   @spec get(t, key, value) :: value
   def get(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
@@ -259,34 +221,23 @@ defmodule Keyword do
   """
   @spec get_and_update(t, key, (value -> {get, value} | :pop)) :: {get, t} when get: term
   def get_and_update(keywords, key, fun)
-      when is_list(keywords) and is_atom(key),
-      do: get_and_update(keywords, [], key, fun)
+    when is_list(keywords) and is_atom(key),
+    do: get_and_update(keywords, [], key, fun)
 
   defp get_and_update([{key, current} | t], acc, key, fun) do
     case fun.(current) do
-      {get, value} ->
-        {get, :lists.reverse(acc, [{key, value} | t])}
-
-      :pop ->
-        {current, :lists.reverse(acc, t)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+      {get, value} -> {get, :lists.reverse(acc, [{key, value} | t])}
+      :pop         -> {current, :lists.reverse(acc, t)}
     end
   end
 
-  defp get_and_update([{_, _} = h | t], acc, key, fun), do: get_and_update(t, [h | acc], key, fun)
+  defp get_and_update([h | t], acc, key, fun),
+    do: get_and_update(t, [h | acc], key, fun)
 
   defp get_and_update([], acc, key, fun) do
     case fun.(nil) do
-      {get, update} ->
-        {get, [{key, update} | :lists.reverse(acc)]}
-
-      :pop ->
-        {nil, :lists.reverse(acc)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+      {get, update} -> {get, [{key, update} | :lists.reverse(acc)]}
+      :pop -> {nil, :lists.reverse(acc)}
     end
   end
 
@@ -328,12 +279,8 @@ defmodule Keyword do
     case fun.(value) do
       {get, value} ->
         {get, :lists.reverse(acc, [{key, value} | delete(keywords, key)])}
-
       :pop ->
         {value, :lists.reverse(acc, keywords)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
     end
   end
 
@@ -406,7 +353,6 @@ defmodule Keyword do
       {^key, val} -> {true, val}
       {_, _} -> false
     end
-
     :lists.filtermap(fun, keywords)
   end
 
@@ -465,22 +411,7 @@ defmodule Keyword do
   """
   @spec delete(t, key, value) :: t
   def delete(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_key_value(keywords, key, value)
-      _ -> keywords
-    end
-  end
-
-  defp delete_key_value([{key, value} | tail], key, value) do
-    delete_key_value(tail, key, value)
-  end
-
-  defp delete_key_value([{_, _} = pair | tail], key, value) do
-    [pair | delete_key_value(tail, key, value)]
-  end
-
-  defp delete_key_value([], _key, _value) do
-    []
+    :lists.filter(fn {k, v} -> k != key or v != value end, keywords)
   end
 
   @doc """
@@ -501,24 +432,8 @@ defmodule Keyword do
 
   """
   @spec delete(t, key) :: t
-  @compile {:inline, delete: 2}
   def delete(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_key(keywords, key)
-      _ -> keywords
-    end
-  end
-
-  defp delete_key([{key, _} | tail], key) do
-    delete_key(tail, key)
-  end
-
-  defp delete_key([{_, _} = pair | tail], key) do
-    [pair | delete_key(tail, key)]
-  end
-
-  defp delete_key([], _key) do
-    []
+    :lists.filter(fn {k, _} -> k != key end, keywords)
   end
 
   @doc """
@@ -536,22 +451,7 @@ defmodule Keyword do
   """
   @spec delete_first(t, key) :: t
   def delete_first(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keymember(key, 1, keywords) do
-      true -> delete_first_key(keywords, key)
-      _ -> keywords
-    end
-  end
-
-  defp delete_first_key([{key, _} | tail], key) do
-    tail
-  end
-
-  defp delete_first_key([{_, _} = pair | tail], key) do
-    [pair | delete_first_key(tail, key)]
-  end
-
-  defp delete_first_key([], _key) do
-    []
+    :lists.keydelete(key, 1, keywords)
   end
 
   @doc """
@@ -624,39 +524,6 @@ defmodule Keyword do
     end
   end
 
-  @doc false
-  @deprecated "Use Keyword.fetch/2 + Keyword.put/3 instead"
-  def replace(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> [{key, value} | delete(keywords, key)]
-      false -> keywords
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `keywords`.
-
-  If `key` is not present in `keywords`, a `KeyError` exception is raised.
-
-  ## Examples
-
-      iex> Keyword.replace!([a: 1, b: 2, a: 4], :a, 3)
-      [a: 3, b: 2]
-
-      iex> Keyword.replace!([a: 1], :b, 2)
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @doc since: "1.5.0"
-  @spec replace!(t, key, value) :: t
-  def replace!(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> [{key, value} | delete(keywords, key)]
-      false -> raise KeyError, key: key, term: keywords
-    end
-  end
-
   @doc """
   Checks if two keywords are equal.
 
@@ -694,32 +561,11 @@ defmodule Keyword do
       iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
       [b: 2, a: 3, d: 4, a: 5]
 
-      iex> Keyword.merge([a: 1], [2, 3])
-      ** (ArgumentError) expected a keyword list as the second argument, got: [2, 3]
-
   """
   @spec merge(t, t) :: t
-  def merge(keywords1, keywords2)
-
-  def merge(keywords1, []), do: keywords1
-  def merge([], keywords2), do: keywords2
-
   def merge(keywords1, keywords2) when is_list(keywords1) and is_list(keywords2) do
-    if keyword?(keywords2) do
-      fun = fn
-        {key, _value} when is_atom(key) ->
-          not has_key?(keywords2, key)
-
-        _ ->
-          raise ArgumentError,
-            message: "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
-      end
-
-      :lists.filter(fun, keywords1) ++ keywords2
-    else
-      raise ArgumentError,
-        message: "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
-    end
+    fun = fn {k, _v} -> not has_key?(keywords2, k) end
+    :lists.filter(fun, keywords1) ++ keywords2
   end
 
   @doc """
@@ -750,44 +596,26 @@ defmodule Keyword do
       ...> end)
       [b: 2, a: 4, d: 4, a: 8]
 
-      iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
-      ...>  v1 + v2
-      ...> end)
-      ** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]
-
   """
   @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(keywords1, keywords2, fun)
-      when is_list(keywords1) and is_list(keywords2) and is_function(fun, 3) do
-    if keyword?(keywords1) do
-      do_merge(keywords2, [], keywords1, keywords1, fun, keywords2)
-    else
-      raise ArgumentError,
-        message: "expected a keyword list as the first argument, got: #{inspect(keywords1)}"
-    end
+  def merge(keywords1, keywords2, fun) when is_list(keywords1) and is_list(keywords2) do
+    do_merge(keywords2, [], keywords1, keywords1, fun)
   end
 
-  defp do_merge([{key, value2} | tail], acc, rest, original, fun, keywords2) when is_atom(key) do
-    case :lists.keyfind(key, 1, original) do
-      {^key, value1} ->
-        acc = [{key, fun.(key, value1, value2)} | acc]
-        original = :lists.keydelete(key, 1, original)
-        do_merge(tail, acc, delete(rest, key), original, fun, keywords2)
-
+  defp do_merge([{k, v2} | t], acc, rest, original, fun) do
+    case :lists.keyfind(k, 1, original) do
+      {^k, v1} ->
+        do_merge(t, [{k, fun.(k, v1, v2)} | acc],
+                 delete(rest, k), :lists.keydelete(k, 1, original), fun)
       false ->
-        do_merge(tail, [{key, value2} | acc], rest, original, fun, keywords2)
+        do_merge(t, [{k, v2} | acc], rest, original, fun)
     end
   end
 
-  defp do_merge([], acc, rest, _original, _fun, _keywords2) do
+  defp do_merge([], acc, rest, _original, _fun) do
     rest ++ :lists.reverse(acc)
   end
 
-  defp do_merge(_other, _acc, _rest, _original, _fun, keywords2) do
-    raise ArgumentError,
-      message: "expected a keyword list as the second argument, got: #{inspect(keywords2)}"
-  end
-
   @doc """
   Returns whether a given `key` exists in the given `keywords`.
 
@@ -891,11 +719,10 @@ defmodule Keyword do
       {[a: 1, c: 3, a: 4], [b: 2]}
 
   """
-  @spec split(t, [key]) :: {t, t}
   def split(keywords, keys) when is_list(keywords) do
     fun = fn {k, v}, {take, drop} ->
       case k in keys do
-        true -> {[{k, v} | take], drop}
+        true  -> {[{k, v} | take], drop}
         false -> {take, [{k, v} | drop]}
       end
     end
@@ -919,7 +746,6 @@ defmodule Keyword do
       [a: 1, c: 3, a: 5]
 
   """
-  @spec take(t, [key]) :: t
   def take(keywords, keys) when is_list(keywords) do
     :lists.filter(fn {k, _} -> k in keys end, keywords)
   end
@@ -937,9 +763,8 @@ defmodule Keyword do
       [a: 1, c: 3, a: 5]
 
   """
-  @spec drop(t, [key]) :: t
   def drop(keywords, keys) when is_list(keywords) do
-    :lists.filter(fn {key, _} -> key not in keys end, keywords)
+    :lists.filter(fn {k, _} -> not k in keys end, keywords)
   end
 
   @doc """
@@ -965,7 +790,6 @@ defmodule Keyword do
     case fetch(keywords, key) do
       {:ok, value} ->
         {value, delete(keywords, key)}
-
       :error ->
         {default, keywords}
     end
@@ -999,7 +823,6 @@ defmodule Keyword do
     case fetch(keywords, key) do
       {:ok, value} ->
         {value, delete(keywords, key)}
-
       :error ->
         {fun.(), keywords}
     end
@@ -1012,13 +835,13 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.pop_first([a: 1], :a)
+      iex> Keyword.pop_first [a: 1], :a
       {1, []}
-      iex> Keyword.pop_first([a: 1], :b)
+      iex> Keyword.pop_first [a: 1], :b
       {nil, [a: 1]}
-      iex> Keyword.pop_first([a: 1], :b, 3)
+      iex> Keyword.pop_first [a: 1], :b, 3
       {3, [a: 1]}
-      iex> Keyword.pop_first([a: 1, a: 2], :a)
+      iex> Keyword.pop_first [a: 1, a: 2], :a
       {1, [a: 2]}
 
   """
@@ -1039,15 +862,14 @@ defmodule Keyword do
       [a: 1]
 
   """
-  @spec to_list(t) :: t
   def to_list(keyword) when is_list(keyword) do
     keyword
   end
 
   @doc false
   # TODO: Remove on 2.0
-  @deprecated "Use Kernel.length/1 instead"
   def size(keyword) do
+    IO.warn "Keyword.size/1 is deprecated, please use Kernel.length/1"
     length(keyword)
   end
 end

lib/elixir/lib/list.ex

@@ -1,77 +1,24 @@
 defmodule List do
   @moduledoc """
-  Functions that work on (linked) lists.
+  Specialized functions that only work on lists.
 
-  Many of the functions provided for lists, which implement
-  the `Enumerable` protocol, are found in the `Enum` module.
+  In general, favor using the `Enum` API instead of `List`.
 
-  Additionally, the following functions and operators for lists are
-  found in `Kernel`:
+  Index access for list is linear. Negative indexes are also
+  supported but they imply the list will be iterated twice,
+  one to calculate the proper index and another to perform the
+  operation.
 
-    * `++/2`
-    * `--/2`
-    * `hd/1`
-    * `tl/1`
-    * `in/2`
-    * `length/1`
-
-  Lists in Elixir are specified between square brackets:
-
-      iex> [1, "two", 3, :four]
-      [1, "two", 3, :four]
-
-  Two lists can be concatenated and subtracted using the
-  `Kernel.++/2` and `Kernel.--/2` operators:
-
-      iex> [1, 2, 3] ++ [4, 5, 6]
-      [1, 2, 3, 4, 5, 6]
-      iex> [1, true, 2, false, 3, true] -- [true, false]
-      [1, 2, 3, true]
-
-  Lists in Elixir are effectively linked lists, which means
-  they are internally represented in pairs containing the
-  head and the tail of a list:
-
-      iex> [head | tail] = [1, 2, 3]
-      iex> head
-      1
-      iex> tail
-      [2, 3]
-
-  Similarly, we could write the list `[1, 2, 3]` using only
-  such pairs (called cons cells):
-
-      iex> [1 | [2 | [3 | []]]]
-      [1, 2, 3]
-
-  Some lists, called improper lists, do not have an empty list as
-  the second element in the last cons cell:
-
-      iex> [1 | [2 | [3 | 4]]]
-      [1, 2, 3 | 4]
-
-  Although improper lists are generally avoided, they are used in some
-  special circumstances like iodata and chardata entities (see the `IO` module).
-
-  Due to their cons cell based representation, prepending an element
-  to a list is always fast (constant time), while appending becomes
-  slower as the list grows in size (linear time):
-
-      iex> list = [1, 2, 3]
-      iex> [0 | list] # fast
-      [0, 1, 2, 3]
-      iex> list ++ [4] # slow
-      [1, 2, 3, 4]
-
-  Additonally, getting a list's length and accessing it by index are
-  linear time operations. Negative indexes are also supported but
-  they imply the list will be iterated twice, once to calculate the
-  proper index and another time to perform the operation.
+  A decision was taken to delegate most functions to
+  Erlang's standard library but follow Elixir's convention
+  of receiving the subject (in this case, a list) as the
+  first argument.
 
   ## Charlists
 
-  If a list is made of non-negative integers, it can also be called
-  a charlist. Elixir uses single quotes to define charlists:
+  If a list is made of non-negative integers, it can also
+  be called as a charlist. Elixir uses single quotes to
+  define charlists:
 
       iex> 'héllo'
       [104, 233, 108, 108, 111]
@@ -85,42 +32,36 @@ defmodule List do
   The rationale behind this behaviour is to better support
   Erlang libraries which may return text as charlists
   instead of Elixir strings. One example of such functions
-  is `Application.loaded_applications/0`:
+  is `Application.loaded_applications`:
 
       Application.loaded_applications
       #=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
-      #=>   {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
-      #=>   {:elixir, 'elixir', '1.0.0'},
-      #=>   {:kernel, 'ERTS  CXC 138 10', '4.1'},
-      #=>   {:logger, 'logger', '1.0.0'}]
-
-  A list can be checked if it is made of printable ascii
-  codepoints with `ascii_printable?/2`.
+            {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
+            {:elixir, 'elixir', '1.0.0'},
+            {:kernel, 'ERTS  CXC 138 10', '4.1'},
+            {:logger, 'logger', '1.0.0'}]
   """
 
   @compile :inline_list_funcs
 
   @doc """
-  Deletes the given `item` from the `list`. Returns a new list without
-  the item.
-
-  If the `item` occurs more than once in the `list`, just
+  Deletes the given item from the list. Returns a list without
+  the item. If the item occurs more than once in the list, just
   the first occurrence is removed.
 
   ## Examples
 
-      iex> List.delete([:a, :b, :c], :a)
-      [:b, :c]
+      iex> List.delete([1, 2, 3], 1)
+      [2, 3]
 
-      iex> List.delete([:a, :b, :b, :c], :b)
-      [:a, :b, :c]
+      iex> List.delete([1, 2, 2, 3], 2)
+      [1, 2, 3]
 
   """
   @spec delete(list, any) :: list
-  def delete(list, item)
-  def delete([item | list], item), do: list
-  def delete([other | list], item), do: [other | delete(list, item)]
-  def delete([], _item), do: []
+  def delete(list, item) do
+    :lists.delete(item, list)
+  end
 
   @doc """
   Duplicates the given element `n` times in a list.
@@ -133,6 +74,7 @@ defmodule List do
       iex> List.duplicate([1, 2], 2)
       [[1, 2], [1, 2]]
 
+
   """
   @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
   def duplicate(elem, n) do
@@ -175,16 +117,16 @@ defmodule List do
 
   ## Examples
 
-      iex> List.foldl([5, 5], 10, fn x, acc -> x + acc end)
+      iex> List.foldl([5, 5], 10, fn(x, acc) -> x + acc end)
       20
 
-      iex> List.foldl([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
+      iex> List.foldl([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
       2
 
   """
   @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldl(list, acc, fun) when is_list(list) and is_function(fun) do
-    :lists.foldl(fun, acc, list)
+  def foldl(list, acc, function) when is_list(list) and is_function(function) do
+    :lists.foldl(function, acc, list)
   end
 
   @doc """
@@ -193,13 +135,13 @@ defmodule List do
 
   ## Examples
 
-      iex> List.foldr([1, 2, 3, 4], 0, fn x, acc -> x - acc end)
+      iex> List.foldr([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
       -2
 
   """
   @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldr(list, acc, fun) when is_list(list) and is_function(fun) do
-    :lists.foldr(fun, acc, list)
+  def foldr(list, acc, function) when is_list(list) and is_function(function) do
+    :lists.foldr(function, acc, list)
   end
 
   @doc """
@@ -218,8 +160,8 @@ defmodule List do
 
   """
   @spec first([elem]) :: nil | elem when elem: var
-  def first([]), do: nil
-  def first([head | _]), do: head
+  def first([]),      do: nil
+  def first([h | _]), do: h
 
   @doc """
   Returns the last element in `list` or `nil` if `list` is empty.
@@ -237,9 +179,9 @@ defmodule List do
 
   """
   @spec last([elem]) :: nil | elem when elem: var
-  def last([]), do: nil
-  def last([head]), do: head
-  def last([_ | tail]), do: last(tail)
+  def last([]),      do: nil
+  def last([h]),     do: h
+  def last([_ | t]), do: last(t)
 
   @doc """
   Receives a list of tuples and returns the first tuple
@@ -280,7 +222,7 @@ defmodule List do
       false
 
   """
-  @spec keymember?([tuple], any, non_neg_integer) :: boolean
+  @spec keymember?([tuple], any, non_neg_integer) :: any
   def keymember?(list, key, position) do
     :lists.keymember(key, position + 1, list)
   end
@@ -319,10 +261,9 @@ defmodule List do
   end
 
   @doc """
-  Receives a `list` of tuples and replaces the item
-  identified by `key` at `position`.
-
-  If the item does not exist, it is added to the end of the `list`.
+  Receives a list of tuples and replaces the item
+  identified by `key` at `position`. If the item
+  does not exist, it is added to the end of the list.
 
   ## Examples
 
@@ -339,7 +280,7 @@ defmodule List do
   end
 
   @doc """
-  Receives a `list` of tuples and deletes the first tuple
+  Receives a list of tuples and deletes the first tuple
   where the item at `position` matches the
   given `key`. Returns the new list.
 
@@ -383,15 +324,14 @@ defmodule List do
   def keytake(list, key, position) do
     case :lists.keytake(key, position + 1, list) do
       {:value, item, list} -> {item, list}
-      false -> nil
+      false                -> nil
     end
   end
 
   @doc """
-  Wraps `term` in a list if this is not list.
-
-  If `term` is already a list, it returns the list.
-  If `term` is `nil`, it returns an empty list.
+  Wraps the argument in a list.
+  If the argument is already a list, returns the list.
+  If the argument is `nil`, returns an empty list.
 
   ## Examples
 
@@ -405,11 +345,7 @@ defmodule List do
       []
 
   """
-  @spec wrap(nil) :: []
-  @spec wrap(list) :: list when list: maybe_improper_list()
-  @spec wrap(term) :: nonempty_list(term) when term: any()
-  def wrap(term)
-
+  @spec wrap(list | any) :: list
   def wrap(list) when is_list(list) do
     list
   end
@@ -438,92 +374,14 @@ defmodule List do
   """
   @spec zip([list]) :: [tuple]
   def zip([]), do: []
-
   def zip(list_of_lists) when is_list(list_of_lists) do
     do_zip(list_of_lists, [])
   end
 
-  @doc """
-  Checks if a list is a charlist made only of printable ASCII characters.
-
-  A printable charlist in Elixir contains only ASCII characters.
-
-  Takes an optional `limit` as a second argument. `ascii_printable?/2` only
-  checks the printability of the list up to the `limit`.
-
-  ## Examples
-
-      iex> List.ascii_printable?('abc')
-      true
-
-      iex> List.ascii_printable?('abc' ++ [0])
-      false
-
-      iex> List.ascii_printable?('abc' ++ [0], 2)
-      true
-
-  Improper lists are not printable, even if made only of ascii characters:
-
-      iex> List.ascii_printable?('abc' ++ ?d)
-      false
-
-  """
-  @doc since: "1.6.0"
-  def ascii_printable?(list, counter \\ :infinity)
-
-  def ascii_printable?(_, 0) do
-    true
-  end
-
-  def ascii_printable?([char | rest], counter)
-      when is_integer(char) and char >= 32 and char <= 126 do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\n | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\r | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\t | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\v | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\b | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\f | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\e | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([?\a | rest], counter) do
-    ascii_printable?(rest, decrement(counter))
-  end
-
-  def ascii_printable?([], _counter), do: true
-  def ascii_printable?(_, _counter), do: false
-
-  @compile {:inline, decrement: 1}
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter), do: counter - 1
-
   @doc """
   Returns a list with `value` inserted at the specified `index`.
-
   Note that `index` is capped at the list length. Negative indices
-  indicate an offset from the end of the `list`.
+  indicate an offset from the end of the list.
 
   ## Examples
 
@@ -541,7 +399,7 @@ defmodule List do
 
   """
   @spec insert_at(list, integer, any) :: list
-  def insert_at(list, index, value) when is_integer(index) do
+  def insert_at(list, index, value) do
     if index < 0 do
       do_insert_at(list, length(list) + index + 1, value)
     else
@@ -551,8 +409,7 @@ defmodule List do
 
   @doc """
   Returns a list with a replaced value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
+  Negative indices indicate an offset from the end of the list.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -571,7 +428,7 @@ defmodule List do
 
   """
   @spec replace_at(list, integer, any) :: list
-  def replace_at(list, index, value) when is_integer(index) do
+  def replace_at(list, index, value) do
     if index < 0 do
       do_replace_at(list, length(list) + index, value)
     else
@@ -581,8 +438,7 @@ defmodule List do
 
   @doc """
   Returns a list with an updated value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
+  Negative indices indicate an offset from the end of the list.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -601,7 +457,7 @@ defmodule List do
 
   """
   @spec update_at([elem], integer, (elem -> any)) :: list when elem: var
-  def update_at(list, index, fun) when is_function(fun, 1) and is_integer(index) do
+  def update_at(list, index, fun) do
     if index < 0 do
       do_update_at(list, length(list) + index, fun)
     else
@@ -611,8 +467,7 @@ defmodule List do
 
   @doc """
   Produces a new list by removing the value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
+  Negative indices indicate an offset from the end of the list.
   If `index` is out of bounds, the original `list` is returned.
 
   ## Examples
@@ -628,68 +483,14 @@ defmodule List do
 
   """
   @spec delete_at(list, integer) :: list
-  def delete_at(list, index) when is_integer(index) do
-    elem(pop_at(list, index), 1)
-  end
-
-  @doc """
-  Returns and removes the value at the specified `index` in the `list`.
-
-  Negative indices indicate an offset from the end of the `list`.
-  If `index` is out of bounds, the original `list` is returned.
-
-  ## Examples
-
-      iex> List.pop_at([1, 2, 3], 0)
-      {1, [2, 3]}
-      iex> List.pop_at([1, 2, 3], 5)
-      {nil, [1, 2, 3]}
-      iex> List.pop_at([1, 2, 3], 5, 10)
-      {10, [1, 2, 3]}
-      iex> List.pop_at([1, 2, 3], -1)
-      {3, [1, 2]}
-
-  """
-  @doc since: "1.4.0"
-  @spec pop_at(list, integer, any) :: {any, list}
-  def pop_at(list, index, default \\ nil) when is_integer(index) do
+  def delete_at(list, index) do
     if index < 0 do
-      do_pop_at(list, length(list) + index, default, [])
+      do_delete_at(list, length(list) + index)
     else
-      do_pop_at(list, index, default, [])
+      do_delete_at(list, index)
     end
   end
 
-  @doc """
-  Returns `true` if `list` starts with the given `prefix` list; otherwise returns `false`.
-
-  If `prefix` is an empty list, it returns `true`.
-
-  ### Examples
-
-      iex> List.starts_with?([1, 2, 3], [1, 2])
-      true
-
-      iex> List.starts_with?([1, 2], [1, 2, 3])
-      false
-
-      iex> List.starts_with?([:alpha], [])
-      true
-
-      iex> List.starts_with?([], [:alpha])
-      false
-
-  """
-  @doc since: "1.5.0"
-  @spec starts_with?(list, list) :: boolean
-  @spec starts_with?(list, []) :: true
-  @spec starts_with?([], nonempty_list) :: false
-  def starts_with?(list, prefix)
-
-  def starts_with?([head | tail], [head | prefix_tail]), do: starts_with?(tail, prefix_tail)
-  def starts_with?(list, []) when is_list(list), do: true
-  def starts_with?(list, [_ | _]) when is_list(list), do: false
-
   @doc """
   Converts a charlist to an atom.
 
@@ -813,11 +614,8 @@ defmodule List do
       iex> List.to_string([0x0061, "bc"])
       "abc"
 
-      iex> List.to_string([0x0064, "ee", ['p']])
-      "deep"
-
   """
-  @spec to_string(:unicode.charlist()) :: String.t()
+  @spec to_string(:unicode.charlist) :: String.t
   def to_string(list) when is_list(list) do
     try do
       :unicode.characters_to_binary(list)
@@ -834,7 +632,7 @@ defmodule List do
 
         Please check the given list or call inspect/1 to get the list representation, got:
 
-        #{inspect(list)}
+        #{inspect list}
         """
     else
       result when is_binary(result) ->
@@ -848,112 +646,6 @@ defmodule List do
     end
   end
 
-  @doc """
-  Returns a keyword list that represents an *edit script*.
-
-  The algorithm is outlined in the
-  "An O(ND) Difference Algorithm and Its Variations" paper by E. Myers.
-
-  An *edit script* is a keyword list. Each key describes the "editing action" to
-  take in order to bring `list1` closer to being equal to `list2`; a key can be
-  `:eq`, `:ins`, or `:del`. Each value is a sublist of either `list1` or `list2`
-  that should be inserted (if the corresponding key `:ins`), deleted (if the
-  corresponding key is `:del`), or left alone (if the corresponding key is
-  `:eq`) in `list1` in order to be closer to `list2`.
-
-  ## Examples
-
-      iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
-      [eq: [1], del: [4], eq: [2, 3], ins: [4]]
-
-  """
-  @doc since: "1.4.0"
-  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}]
-  def myers_difference(list1, list2) when is_list(list1) and is_list(list2) do
-    path = {0, list1, list2, []}
-    find_script(0, length(list1) + length(list2), [path])
-  end
-
-  defp find_script(envelope, max, paths) do
-    case each_diagonal(-envelope, envelope, paths, []) do
-      {:done, edits} -> compact_reverse(edits, [])
-      {:next, paths} -> find_script(envelope + 1, max, paths)
-    end
-  end
-
-  defp compact_reverse([], acc), do: acc
-
-  defp compact_reverse([{kind, elem} | rest], [{kind, result} | acc]) do
-    compact_reverse(rest, [{kind, [elem | result]} | acc])
-  end
-
-  defp compact_reverse(rest, [{:eq, elem}, {:ins, elem}, {:eq, other} | acc]) do
-    compact_reverse(rest, [{:ins, elem}, {:eq, elem ++ other} | acc])
-  end
-
-  defp compact_reverse([{kind, elem} | rest], acc) do
-    compact_reverse(rest, [{kind, [elem]} | acc])
-  end
-
-  defp each_diagonal(diag, limit, _paths, next_paths) when diag > limit do
-    {:next, :lists.reverse(next_paths)}
-  end
-
-  defp each_diagonal(diag, limit, paths, next_paths) do
-    {path, rest} = proceed_path(diag, limit, paths)
-
-    case follow_snake(path) do
-      {:cont, path} -> each_diagonal(diag + 2, limit, rest, [path | next_paths])
-      {:done, edits} -> {:done, edits}
-    end
-  end
-
-  defp proceed_path(0, 0, [path]), do: {path, []}
-
-  defp proceed_path(diag, limit, [path | _] = paths) when diag == -limit do
-    {move_down(path), paths}
-  end
-
-  defp proceed_path(diag, limit, [path]) when diag == limit do
-    {move_right(path), []}
-  end
-
-  defp proceed_path(_diag, _limit, [path1, path2 | rest]) do
-    if elem(path1, 0) > elem(path2, 0) do
-      {move_right(path1), [path2 | rest]}
-    else
-      {move_down(path2), [path2 | rest]}
-    end
-  end
-
-  defp move_right({y, list1, [elem | rest], edits}) do
-    {y, list1, rest, [{:ins, elem} | edits]}
-  end
-
-  defp move_right({y, list1, [], edits}) do
-    {y, list1, [], edits}
-  end
-
-  defp move_down({y, [elem | rest], list2, edits}) do
-    {y + 1, rest, list2, [{:del, elem} | edits]}
-  end
-
-  defp move_down({y, [], list2, edits}) do
-    {y + 1, [], list2, edits}
-  end
-
-  defp follow_snake({y, [elem | rest1], [elem | rest2], edits}) do
-    follow_snake({y + 1, rest1, rest2, [{:eq, elem} | edits]})
-  end
-
-  defp follow_snake({_y, [], [], edits}) do
-    {:done, edits}
-  end
-
-  defp follow_snake(path) do
-    {:cont, path}
-  end
-
   ## Helpers
 
   # replace_at
@@ -970,8 +662,8 @@ defmodule List do
     [value | rest]
   end
 
-  defp do_replace_at([head | tail], index, value) do
-    [head | do_replace_at(tail, index - 1, value)]
+  defp do_replace_at([h | t], index, value) do
+    [h | do_replace_at(t, index - 1, value)]
   end
 
   # insert_at
@@ -984,8 +676,8 @@ defmodule List do
     [value | list]
   end
 
-  defp do_insert_at([head | tail], index, value) do
-    [head | do_insert_at(tail, index - 1, value)]
+  defp do_insert_at([h | t], index, value) do
+    [h | do_insert_at(t, index - 1, value)]
   end
 
   # update_at
@@ -998,41 +690,38 @@ defmodule List do
     list
   end
 
-  defp do_update_at([head | tail], index, fun) do
-    [head | do_update_at(tail, index - 1, fun)]
+  defp do_update_at([h | t], index, fun) do
+    [h | do_update_at(t, index - 1, fun)]
   end
 
   defp do_update_at([], _index, _fun) do
     []
   end
 
-  # pop_at
+  # delete_at
 
-  defp do_pop_at([], _index, default, acc) do
-    {default, :lists.reverse(acc)}
+  defp do_delete_at([], _index) do
+    []
   end
 
-  defp do_pop_at(list, index, default, []) when index < 0 do
-    {default, list}
+  defp do_delete_at([_ | t], 0) do
+    t
   end
 
-  defp do_pop_at([head | tail], 0, _default, acc) do
-    {head, :lists.reverse(acc, tail)}
+  defp do_delete_at(list, index) when index < 0 do
+    list
   end
 
-  defp do_pop_at([head | tail], index, default, acc) do
-    do_pop_at(tail, index - 1, default, [head | acc])
+  defp do_delete_at([h | t], index) do
+    [h | do_delete_at(t, index - 1)]
   end
 
   # zip
 
   defp do_zip(list, acc) do
     converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-
     case :lists.mapfoldl(converter, [], list) do
-      {_, nil} ->
-        :lists.reverse(acc)
-
+      {_, nil} -> :lists.reverse(acc)
       {mlist, heads} ->
         do_zip(mlist, [to_tuple(:lists.reverse(heads)) | acc])
     end
@@ -1042,8 +731,8 @@ defmodule List do
     {nil, nil}
   end
 
-  defp do_zip_each([head | tail], acc) do
-    {tail, [head | acc]}
+  defp do_zip_each([h | t], acc) do
+    {t, [h | acc]}
   end
 
   defp do_zip_each([], _) do
@@ -1051,5 +740,5 @@ defmodule List do
   end
 
   defp to_list(tuple) when is_tuple(tuple), do: Tuple.to_list(tuple)
-  defp to_list(list) when is_list(list), do: list
+  defp to_list(list)  when is_list(list),   do: list
 end

lib/elixir/lib/list/chars.ex

@@ -1,24 +1,18 @@
 defprotocol List.Chars do
   @moduledoc ~S"""
-  The `List.Chars` protocol is responsible for
-  converting a structure to a charlist (only if applicable).
-
+  The List.Chars protocol is responsible for
+  converting a structure to a list (only if applicable).
   The only function required to be implemented is
-  `to_charlist/1` which does the conversion.
+  `to_charlist` which does the conversion.
 
-  The `to_charlist/1` function automatically imported
-  by `Kernel` invokes this protocol.
+  The `to_charlist` function automatically imported
+  by Kernel invokes this protocol.
   """
 
-  @doc """
-  Converts `term` to a charlist.
-  """
-  @spec to_charlist(t) :: charlist
   def to_charlist(term)
 
+  # TODO: Deprecate by v1.5
   @doc false
-  # TODO: Remove by 2.0
-  @deprecated "Use List.Chars.to_charlist/1 instead"
   Kernel.def to_char_list(term) do
     __MODULE__.to_charlist(term)
   end
@@ -38,9 +32,9 @@ defimpl List.Chars, for: BitString do
 
   def to_charlist(term) do
     raise Protocol.UndefinedError,
-      protocol: @protocol,
-      value: term,
-      description: "cannot convert a bitstring to a charlist"
+             protocol: @protocol,
+                value: term,
+          description: "cannot convert a bitstring to a charlist"
   end
 end
 

lib/elixir/lib/macro/env.ex

@@ -3,8 +3,8 @@ defmodule Macro.Env do
   A struct that holds compile time environment information.
 
   The current environment can be accessed at any time as
-  `__ENV__/0`. Inside macros, the caller environment can be
-  accessed as `__CALLER__/0`.
+  `__ENV__`. Inside macros, the caller environment can be
+  accessed as `__CALLER__`.
 
   An instance of `Macro.Env` must not be modified by hand. If you need to
   create a custom environment to pass to `Code.eval_quoted/3`, use the
@@ -36,21 +36,12 @@ defmodule Macro.Env do
     * `macros` - a list of macros imported from each module
     * `macro_aliases` - a list of aliases defined inside the current macro
     * `context_modules` - a list of modules defined in the current context
+    * `vars` - a list keeping all defined variables as `{var, context}`
+    * `export_vars` - a list keeping all variables to be exported in a
+      construct (may be `nil`)
     * `lexical_tracker` - PID of the lexical tracker which is responsible for
       keeping user info
-
-  The following fields pertain to variable handling and must not be accessed or
-  relied on. To get a list of all variables, see `vars/1`:
-
-    * `current_vars`
-    * `unused_vars`
-    * `prematch_vars`
-    * `contextual_vars`
-
-  The following fields are deprecated and must not be accessed or relied on:
-
-    * `vars` - a list keeping all defined variables as `{var, context}`
-
+    * `local` - the module to expand local functions to
   """
 
   @type name_arity :: {atom, arity}
@@ -63,42 +54,30 @@ defmodule Macro.Env do
   @type functions :: [{module, [name_arity]}]
   @type macros :: [{module, [name_arity]}]
   @type context_modules :: [module]
-  @type lexical_tracker :: pid | nil
-  @type var :: {atom, atom | non_neg_integer}
+  @type vars :: [{atom, atom | non_neg_integer}]
+  @type export_vars :: vars | nil
+  @type lexical_tracker :: pid
+  @type local :: atom | nil
 
-  @typep vars :: [var]
-  @typep var_type :: :term
-  @typep var_version :: non_neg_integer
-  @typep unused_vars :: %{{var, var_version} => non_neg_integer | false}
-  @typep current_vars :: %{var => {var_version, var_type}}
-  @typep prematch_vars :: current_vars | :warn | :raise | :pin | :apply
-  @typep contextual_vars :: [atom]
+  @type t :: %{__struct__: __MODULE__,
+               module: atom,
+               file: file,
+               line: line,
+               function: name_arity | nil,
+               context: context,
+               requires: requires,
+               aliases: aliases,
+               functions: functions,
+               macros: macros,
+               macro_aliases: aliases,
+               context_modules: context_modules,
+               vars: vars,
+               export_vars: export_vars,
+               lexical_tracker: lexical_tracker,
+               local: local}
 
-  @type t :: %{
-          __struct__: __MODULE__,
-          module: atom,
-          file: file,
-          line: line,
-          function: name_arity | nil,
-          context: context,
-          requires: requires,
-          aliases: aliases,
-          functions: functions,
-          macros: macros,
-          macro_aliases: aliases,
-          context_modules: context_modules,
-          vars: vars,
-          unused_vars: unused_vars,
-          current_vars: current_vars,
-          prematch_vars: prematch_vars,
-          lexical_tracker: lexical_tracker,
-          contextual_vars: contextual_vars
-        }
-
-  # TODO: Remove :vars field on v2.0
   def __struct__ do
-    %{
-      __struct__: __MODULE__,
+    %{__struct__: __MODULE__,
       module: nil,
       file: "nofile",
       line: 0,
@@ -111,68 +90,24 @@ defmodule Macro.Env do
       macro_aliases: [],
       context_modules: [],
       vars: [],
-      unused_vars: %{},
-      current_vars: %{},
-      prematch_vars: :warn,
-      lexical_tracker: nil,
-      contextual_vars: []
-    }
+      export_vars: nil,
+      lexical_tracker: nil}
   end
 
   def __struct__(kv) do
-    Enum.reduce(kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end)
-  end
-
-  @doc """
-  Returns a list of variables in the current environment.
-
-  Each variable is identified by a tuple of two elements,
-  where the first element is the variable name as an atom
-  and the second element is its context, which may be an
-  atom or an integer.
-  """
-  @doc since: "1.7.0"
-  @spec vars(t) :: [var]
-  def vars(env)
-
-  def vars(%{__struct__: Macro.Env, current_vars: current_vars}) do
-    Map.keys(current_vars)
-  end
-
-  @doc """
-  Checks if a variable belongs to the environment.
-  """
-  @doc since: "1.7.0"
-  @spec has_var?(t, var) :: boolean()
-  def has_var?(env, var)
-
-  def has_var?(%{__struct__: Macro.Env, current_vars: current_vars}, var) do
-    Map.has_key?(current_vars, var)
+    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
   end
 
   @doc """
   Returns a keyword list containing the file and line
   information as keys.
   """
-  @spec location(t) :: keyword
+  @spec location(t) :: Keyword.t
   def location(env)
-
   def location(%{__struct__: Macro.Env, file: file, line: line}) do
     [file: file, line: line]
   end
 
-  @doc """
-  Returns a `Macro.Env` in the match context.
-  """
-  @spec to_match(t) :: t
-  def to_match(%{__struct__: Macro.Env, context: :match} = env) do
-    env
-  end
-
-  def to_match(%{__struct__: Macro.Env, current_vars: vars} = env) do
-    %{env | context: :match, prematch_vars: vars}
-  end
-
   @doc """
   Returns whether the compilation environment is currently
   inside a guard.
@@ -197,10 +132,8 @@ defmodule Macro.Env do
     cond do
       is_nil(env.module) ->
         [{:elixir_compiler, :__FILE__, 1, relative_location(env)}]
-
       is_nil(env.function) ->
         [{env.module, :__MODULE__, 0, relative_location(env)}]
-
       true ->
         {name, arity} = env.function
         [{env.module, name, arity, relative_location(env)}]
@@ -208,6 +141,6 @@ defmodule Macro.Env do
   end
 
   defp relative_location(env) do
-    [file: String.to_charlist(Path.relative_to_cwd(env.file)), line: env.line]
+    [file: Path.relative_to_cwd(env.file), line: env.line]
   end
 end

lib/elixir/lib/map.ex

@@ -2,106 +2,19 @@ defmodule Map do
   @moduledoc """
   A set of functions for working with maps.
 
-  Many functions for maps, which implement the `Enumerable` protocol,
-  are found in the `Enum` module. Additionally, the following functions
-  for maps are found in `Kernel`:
-
-    * `map_size/1`
-
-  Maps are the "go to" key-value data structure in Elixir. Maps can be created
-  with the `%{}` syntax, and key-value pairs can be expressed as `key => value`:
-
-      iex> %{}
-      %{}
-      iex> %{"one" => :two, 3 => "four"}
-      %{3 => "four", "one" => :two}
-
-  Key-value pairs in a map do not follow any order (that's why the printed map
-  in the example above has a different order than the map that was created).
-
-  Maps do not impose any restriction on the key type: anything can be a key in a
-  map. As a key-value structure, maps do not allow duplicated keys. Keys are
-  compared using the exact-equality operator (`===/2`). If colliding keys are defined
-  in a map literal, the last one prevails.
-
-  When the key in a key-value pair is an atom, the `key: value` shorthand syntax
-  can be used (as in many other special forms), provided key-value pairs are put at
-  the end:
-
-      iex> %{"hello" => "world", a: 1, b: 2}
-      %{:a => 1, :b => 2, "hello" => "world"}
-
-  Keys in maps can be accessed through some of the functions in this module
-  (such as `Map.get/3` or `Map.fetch/2`) or through the `map[]` syntax provided
-  by the `Access` module:
-
-      iex> map = %{a: 1, b: 2}
-      iex> Map.fetch(map, :a)
-      {:ok, 1}
-      iex> map[:b]
-      2
-      iex> map["non_existing_key"]
-      nil
-
-  For accessing atom keys, one may also `map.key`. Note that while `map[key]` will
-  return `nil` if `map` doesn't contain `key`, `map.key` will raise if `map` doesn't
-  contain the key `:key`.
-
-      iex> map = %{foo: "bar", baz: "bong"}
-      iex> map.foo
-      "bar"
-      iex> map.non_existing_key
-      ** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}
-
-  The two syntaxes for accessing keys reveal the dual nature of maps. The `map[key]`
-  syntax is used for dynamically created maps that may have any key, of any type.
-  `map.key` is used with maps that hold a predetermined set of atoms keys, which are
-  expected to always be present. Structs, defined via `defstruct/1`, are one example
-  of such "static maps", where the keys can also be checked during compile time.
-
-  Maps can be pattern matched on. When a map is on the left-hand side of a
-  pattern match, it will match if the map on the right-hand side contains the
-  keys on the left-hand side and their values match the ones on the left-hand
-  side. This means that an empty map matches every map.
-
-      iex> %{} = %{foo: "bar"}
-      %{foo: "bar"}
-      iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
-      iex> a
-      1
-      iex> %{:c => 3} = %{:a => 1, 2 => :b}
-      ** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}
-
-  Variables can be used as map keys both when writing map literals as well as
-  when matching:
-
-      iex> n = 1
-      1
-      iex> %{n => :one}
-      %{1 => :one}
-      iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
-      %{1 => :one, 2 => :two, 3 => :three}
-
-  Maps also support a specific update syntax to update the value stored under
-  *existing* atom keys:
-
-      iex> map = %{one: 1, two: 2}
-      iex> %{map | one: "one"}
-      %{one: "one", two: 2}
-      iex> %{map | three: 3}
-      ** (KeyError) key :three not found
-
+  Maps are key-value stores where keys can be any value and
+  are compared using the match operator (`===`). Maps can be
+  created with the `%{}` special form defined in the
+  `Kernel.SpecialForms` module.
   """
 
   @type key :: any
   @type value :: any
-  @compile {:inline, fetch: 2, fetch!: 2, get: 2, put: 3, delete: 2, has_key?: 2, replace!: 3}
+  @compile {:inline, fetch: 2, put: 3, delete: 2, has_key?: 2}
 
   @doc """
   Returns all keys from `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.keys(%{a: 1, b: 2})
@@ -114,8 +27,6 @@ defmodule Map do
   @doc """
   Returns all values from `map`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.values(%{a: 1, b: 2})
@@ -128,11 +39,6 @@ defmodule Map do
   @doc """
   Converts `map` to a list.
 
-  Each key-value pair in the map is converted to a two-element tuple `{key,
-  value}` in the resulting list.
-
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.to_list(%{a: 1})
@@ -149,7 +55,7 @@ defmodule Map do
 
   ## Examples
 
-      iex> Map.new()
+      iex> Map.new
       %{}
 
   """
@@ -169,21 +75,20 @@ defmodule Map do
       %{a: 3}
 
   """
-  @spec new(Enumerable.t()) :: map
+  @spec new(Enum.t) :: map
   def new(enumerable)
-  def new(list) when is_list(list), do: :maps.from_list(list)
-  def new(%_{} = struct), do: new_from_enum(struct)
+  def new(%{__struct__: _} = struct), do: new_from_enum(struct)
   def new(%{} = map), do: map
   def new(enum), do: new_from_enum(enum)
 
   defp new_from_enum(enumerable) do
     enumerable
-    |> Enum.to_list()
-    |> :maps.from_list()
+    |> Enum.to_list
+    |> :maps.from_list
   end
 
   @doc """
-  Creates a map from an `enumerable` via the given transformation function.
+  Creates a map from an `enumerable` via the transformation function.
 
   Duplicated keys are removed; the latest one prevails.
 
@@ -193,27 +98,24 @@ defmodule Map do
       %{a: :a, b: :b}
 
   """
-  @spec new(Enumerable.t(), (term -> {key, value})) :: map
-  def new(enumerable, transform) when is_function(transform, 1) do
+  @spec new(Enum.t, (term -> {key, value})) :: map
+  def new(enumerable, transform) do
     enumerable
-    |> Enum.to_list()
-    |> new_transform(transform, [])
+    |> Enum.to_list
+    |> do_new_transform(transform, [])
   end
 
-  defp new_transform([], _fun, acc) do
+  defp do_new_transform([], _fun, acc) do
     acc
-    |> :lists.reverse()
-    |> :maps.from_list()
+    |> :lists.reverse
+    |> :maps.from_list
   end
-
-  defp new_transform([item | rest], fun, acc) do
-    new_transform(rest, fun, [fun.(item) | acc])
+  defp do_new_transform([item | rest], fun, acc) do
+    do_new_transform(rest, fun, [fun.(item) | acc])
   end
 
   @doc """
-  Returns whether the given `key` exists in the given `map`.
-
-  Inlined by the compiler.
+  Returns whether a given `key` exists in the given `map`.
 
   ## Examples
 
@@ -227,12 +129,9 @@ defmodule Map do
   def has_key?(map, key), do: :maps.is_key(key, map)
 
   @doc """
-  Fetches the value for a specific `key` in the given `map`.
+  Fetches the value for a specific `key` and returns it in a tuple.
 
-  If `map` contains the given `key` with value `value`, then `{:ok, value}` is
-  returned. If `map` doesn't contain `key`, `:error` is returned.
-
-  Inlined by the compiler.
+  If the `key` does not exist, returns `:error`.
 
   ## Examples
 
@@ -246,13 +145,9 @@ defmodule Map do
   def fetch(map, key), do: :maps.find(key, map)
 
   @doc """
-  Fetches the value for a specific `key` in the given `map`, erroring out if
-  `map` doesn't contain `key`.
+  Fetches the value for specific `key`.
 
-  If `map` contains the given `key`, the corresponding value is returned. If
-  `map` doesn't contain `key`, a `KeyError` exception is raised.
-
-  Inlined by the compiler.
+  If `key` does not exist, a `KeyError` is raised.
 
   ## Examples
 
@@ -264,80 +159,38 @@ defmodule Map do
   """
   @spec fetch!(map, key) :: value | no_return
   def fetch!(map, key) do
-    :maps.get(key, map)
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> raise KeyError, key: key, term: map
+    end
   end
 
   @doc """
   Puts the given `value` under `key` unless the entry `key`
-  already exists in `map`.
+  already exists.
 
   ## Examples
 
       iex> Map.put_new(%{a: 1}, :b, 2)
-      %{a: 1, b: 2}
+      %{b: 2, a: 1}
       iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
       %{a: 1, b: 2}
 
   """
   @spec put_new(map, key, value) :: map
   def put_new(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        map
-
-      %{} ->
-        put(map, key, value)
-
-      other ->
-        :erlang.error({:badmap, other})
+    case has_key?(map, key) do
+      true  -> map
+      false -> put(map, key, value)
     end
   end
 
-  @doc false
-  @deprecated "Use Map.fetch/2 + Map.put/3 instead"
-  def replace(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        put(map, key, value)
-
-      %{} ->
-        map
-
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `map`.
-
-  If `key` is not present in `map`, a `KeyError` exception is raised.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-      iex> Map.replace!(%{a: 1}, :b, 2)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @doc since: "1.5.0"
-  @spec replace!(map, key, value) :: map
-  def replace!(map, key, value) do
-    :maps.update(key, value, map)
-  end
-
   @doc """
   Evaluates `fun` and puts the result under `key`
-  in `map` unless `key` is already present.
+  in map unless `key` is already present.
 
-  This function is useful in case you want to compute the value to put under
-  `key` only if `key` is not already present (e.g., the value is expensive to
-  calculate or generally difficult to setup and teardown again).
+  This is useful if the value is very expensive to calculate or
+  generally difficult to setup and teardown again.
 
   ## Examples
 
@@ -354,23 +207,15 @@ defmodule Map do
   """
   @spec put_new_lazy(map, key, (() -> value)) :: map
   def put_new_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => _value} ->
-        map
-
-      %{} ->
-        put(map, key, fun.())
-
-      other ->
-        :erlang.error({:badmap, other})
+    case has_key?(map, key) do
+      true  -> map
+      false -> put(map, key, fun.())
     end
   end
 
   @doc """
-  Returns a new map with all the key-value pairs in `map` where the key
-  is in `keys`.
-
-  If `keys` contains keys that are not in `map`, they're simply ignored.
+  Takes all entries corresponding to the given keys and
+  returns them in a new map.
 
   ## Examples
 
@@ -378,39 +223,27 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec take(map, Enumerable.t()) :: map
-  def take(map, keys)
-
-  def take(map, keys) when is_map(map) do
+  @spec take(map, Enumerable.t) :: map
+  def take(map, keys) do
     keys
-    |> Enum.to_list()
-    |> take(map, [])
+    |> Enum.to_list
+    |> do_take(map, [])
   end
 
-  def take(non_map, _keys) do
-    :erlang.error({:badmap, non_map})
-  end
-
-  defp take([], _map, acc) do
-    :maps.from_list(acc)
-  end
-
-  defp take([key | rest], map, acc) do
-    acc =
-      case map do
-        %{^key => value} -> [{key, value} | acc]
-        %{} -> acc
-      end
-
-    take(rest, map, acc)
+  defp do_take([], _map, acc), do: :maps.from_list(acc)
+  defp do_take([key | rest], map, acc) do
+    acc = case fetch(map, key) do
+      {:ok, value} -> [{key, value} | acc]
+      :error -> acc
+    end
+    do_take(rest, map, acc)
   end
 
   @doc """
-  Gets the value for a specific `key` in `map`.
+  Gets the value for a specific `key`.
 
-  If `key` is present in `map` with value `value`, then `value` is
-  returned. Otherwise, `default` is returned (which is `nil` unless
-  specified otherwise).
+  If `key` does not exist, return the default value
+  (`nil` if no default value).
 
   ## Examples
 
@@ -424,25 +257,19 @@ defmodule Map do
       3
 
   """
+  @spec get(map, key) :: value
   @spec get(map, key, value) :: value
   def get(map, key, default \\ nil) do
-    case map do
-      %{^key => value} ->
-        value
-
-      %{} ->
-        default
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, default])
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> default
     end
   end
 
   @doc """
-  Gets the value for a specific `key` in `map`.
+  Gets the value for a specific `key`.
 
-  If `key` is present in `map` with value `value`, then `value` is
-  returned. Otherwise, `fun` is evaluated and its result is returned.
+  If `key` does not exist, lazily evaluates `fun` and returns its result.
 
   This is useful if the default value is very expensive to calculate or
   generally difficult to setup and teardown again.
@@ -462,22 +289,14 @@ defmodule Map do
   """
   @spec get_lazy(map, key, (() -> value)) :: value
   def get_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => value} ->
-        value
-
-      %{} ->
-        fun.()
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, fun])
+    case fetch(map, key) do
+      {:ok, value} -> value
+      :error -> fun.()
     end
   end
 
   @doc """
-  Puts the given `value` under `key` in `map`.
-
-  Inlined by the compiler.
+  Puts the given `value` under `key`.
 
   ## Examples
 
@@ -488,17 +307,15 @@ defmodule Map do
 
   """
   @spec put(map, key, value) :: map
-  def put(map, key, value) do
-    :maps.put(key, value, map)
+  def put(map, key, val) do
+    :maps.put(key, val, map)
   end
 
   @doc """
-  Deletes the entry in `map` for a specific `key`.
+  Deletes the entries in `map` for a specific `key`.
 
   If the `key` does not exist, returns `map` unchanged.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.delete(%{a: 1, b: 2}, :a)
@@ -513,16 +330,13 @@ defmodule Map do
   @doc """
   Merges two maps into one.
 
-  All keys in `map2` will be added to `map1`, overriding any existing one
-  (i.e., the keys in `map2` "have precedence" over the ones in `map1`).
+  All keys in `map2` will be added to `map1`, overriding any existing one.
 
   If you have a struct and you would like to merge a set of keys into the
   struct, do not use this function, as it would merge all keys on the right
   side into the struct, even if the key is not part of the struct. Instead,
   use `Kernel.struct/2`.
 
-  Inlined by the compiler.
-
   ## Examples
 
       iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
@@ -533,13 +347,10 @@ defmodule Map do
   defdelegate merge(map1, map2), to: :maps
 
   @doc """
-  Merges two maps into one, resolving conflicts through the given `fun`.
+  Merges two maps into one.
 
-  All keys in `map2` will be added to `map1`. The given function will be invoked
-  when there are duplicate keys; its arguments are `key` (the duplicate key),
-  `value1` (the value of `key` in `map1`), and `value2` (the value of `key` in
-  `map2`). The value returned by `fun` is used as the value under `key` in
-  the resulting map.
+  All keys in `map2` will be added to `map1`. The given function will
+  be invoked with the key, value1 and value2 to solve conflicts.
 
   ## Examples
 
@@ -550,29 +361,16 @@ defmodule Map do
 
   """
   @spec merge(map, map, (key, value, value -> value)) :: map
-  def merge(map1, map2, fun) when is_function(fun, 3) do
-    if map_size(map1) > map_size(map2) do
-      folder = fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> fun.(key, val1, val2) end)
-      end
-
-      :maps.fold(folder, map1, map2)
-    else
-      folder = fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> fun.(key, val2, val1) end)
-      end
-
-      :maps.fold(folder, map2, map1)
-    end
+  def merge(map1, map2, callback) do
+    :maps.fold fn k, v2, acc ->
+      update(acc, k, v2, fn(v1) -> callback.(k, v1, v2) end)
+    end, map1, map2
   end
 
   @doc """
   Updates the `key` in `map` with the given function.
 
-  If `key` is present in `map` with value `value`, `fun` is invoked with
-  argument `value` and its result is used as the new value of `key`. If `key` is
-  not present in `map`, `initial` is inserted as the value of `key`. The initial
-  value will not be passed through the update function.
+  If the `key` does not exist, inserts the given `initial` value.
 
   ## Examples
 
@@ -583,26 +381,18 @@ defmodule Map do
 
   """
   @spec update(map, key, value, (value -> value)) :: map
-  def update(map, key, initial, fun) when is_function(fun, 1) do
-    case map do
-      %{^key => value} ->
+  def update(map, key, initial, fun) do
+    case fetch(map, key) do
+      {:ok, value} ->
         put(map, key, fun.(value))
-
-      %{} ->
+      :error ->
         put(map, key, initial)
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, initial, fun])
     end
   end
 
   @doc """
   Returns and removes the value associated with `key` in `map`.
 
-  If `key` is present in `map` with value `value`, `{value, new_map}` is
-  returned where `new_map` is the result of removing `key` from `map`. If `key`
-  is not present in `map`, `{default, map}` is returned.
-
   ## Examples
 
       iex> Map.pop(%{a: 1}, :a)
@@ -615,20 +405,15 @@ defmodule Map do
   """
   @spec pop(map, key, value) :: {value, map}
   def pop(map, key, default \\ nil) do
-    case :maps.take(key, map) do
-      {_, _} = tuple -> tuple
-      :error -> {default, map}
+    case map do
+      %{^key => value} -> {value, delete(map, key)}
+      %{} -> {default, map}
     end
   end
 
   @doc """
   Lazily returns and removes the value associated with `key` in `map`.
 
-  If `key` is present in `map` with value `value`, `{value, new_map}` is
-  returned where `new_map` is the result of removing `key` from `map`. If `key`
-  is not present in `map`, `{fun_result, map}` is returned, where `fun_result`
-  is the result of applying `fun`.
-
   This is useful if the default value is very expensive to calculate or
   generally difficult to setup and teardown again.
 
@@ -647,51 +432,36 @@ defmodule Map do
   """
   @spec pop_lazy(map, key, (() -> value)) :: {value, map}
   def pop_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => value} ->
-        {value, delete(map, key)}
-
-      %{} ->
-        {fun.(), map}
-
-      other ->
-        :erlang.error({:badmap, other}, [map, key, fun])
+    case fetch(map, key) do
+      {:ok, value} -> {value, delete(map, key)}
+      :error -> {fun.(), map}
     end
   end
 
   @doc """
   Drops the given `keys` from `map`.
 
-  If `keys` contains keys that are not in `map`, they're simply ignored.
-
   ## Examples
 
       iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
       %{a: 1, c: 3}
 
   """
-  @spec drop(map, Enumerable.t()) :: map
-  def drop(map, keys)
-
-  def drop(map, keys) when is_map(map) do
+  @spec drop(map, Enumerable.t) :: map
+  def drop(map, keys) do
     keys
-    |> Enum.to_list()
+    |> Enum.to_list
     |> drop_list(map)
   end
 
-  def drop(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
-  end
-
   defp drop_list([], acc), do: acc
-
   defp drop_list([key | rest], acc) do
-    drop_list(rest, delete(acc, key))
+    drop_list(rest, Map.delete(acc, key))
   end
 
   @doc """
-  Takes all entries corresponding to the given `keys` in `map` and extracts
-  them into a separate map.
+  Takes all entries corresponding to the given `keys` and extracts them into a
+  separate `map`.
 
   Returns a tuple with the new map and the old map with removed keys.
 
@@ -703,39 +473,29 @@ defmodule Map do
       {%{a: 1, c: 3}, %{b: 2}}
 
   """
-  @spec split(map, Enumerable.t()) :: {map, map}
-  def split(map, keys)
-
-  def split(map, keys) when is_map(map) do
+  @spec split(map, Enumerable.t) :: {map, map}
+  def split(map, keys) do
     keys
-    |> Enum.to_list()
-    |> split([], map)
+    |> Enum.to_list
+    |> do_split([], map)
   end
 
-  def split(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
+  defp do_split([], inc, exc) do
+    {:maps.from_list(inc), exc}
   end
-
-  defp split([], included, excluded) do
-    {:maps.from_list(included), excluded}
-  end
-
-  defp split([key | rest], included, excluded) do
-    case excluded do
-      %{^key => value} ->
-        split(rest, [{key, value} | included], delete(excluded, key))
-
-      _other ->
-        split(rest, included, excluded)
+  defp do_split([key | rest], inc, exc) do
+    case fetch(exc, key) do
+      {:ok, value} ->
+        do_split(rest, [{key, value} | inc], delete(exc, key))
+      :error ->
+        do_split(rest, inc, exc)
     end
   end
 
   @doc """
-  Updates `key` with the given function.
+  Updates the `key` with the given function.
 
-  If `key` is present in `map` with value `value`, `fun` is invoked with
-  argument `value` and its result is used as the new value of `key`. If `key` is
-  not present in `map`, a `KeyError` exception is raised.
+  If the `key` does not exist, raises `KeyError`.
 
   ## Examples
 
@@ -743,24 +503,30 @@ defmodule Map do
       %{a: 2}
 
       iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
-      ** (KeyError) key :b not found in: %{a: 1}
+      ** (KeyError) key :b not found
 
   """
-  @spec update!(map, key, (value -> value)) :: map
-  def update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-    put(map, key, fun.(value))
+  @spec update!(map, key, (value -> value)) :: map | no_return
+  def update!(%{} = map, key, fun) do
+    case fetch(map, key) do
+      {:ok, value} ->
+        put(map, key, fun.(value))
+      :error ->
+        :erlang.error({:badkey, key})
+    end
   end
 
+  def update!(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Gets the value from `key` and updates it, all in one pass.
 
-  `fun` is called with the current value under `key` in `map` (or `nil` if `key`
-  is not present in `map`) and must return a two-element tuple: the "get" value
-  (the retrieved value, which can be operated on before being returned) and the
-  new value to be stored under `key` in the resulting new map. `fun` may also
-  return `:pop`, which means the current value shall be removed from `map` and
-  returned (making this function behave like `Map.pop(map, key)`).
+  This `fun` argument receives the value of `key` (or `nil` if `key`
+  is not present) and must return a two-element tuple: the "get" value
+  (the retrieved value, which can be operated on before being returned)
+  and the new value to be stored under `key`. The `fun` may also
+  return `:pop`, implying the current value shall be removed
+  from `map` and returned.
 
   The returned value is a tuple with the "get" value returned by
   `fun` and a new map with the updated value under `key`.
@@ -785,26 +551,31 @@ defmodule Map do
 
   """
   @spec get_and_update(map, key, (value -> {get, value} | :pop)) :: {get, map} when get: term
-  def get_and_update(map, key, fun) when is_function(fun, 1) do
-    current = get(map, key)
+  def get_and_update(%{} = map, key, fun) do
+    current =
+      case :maps.find(key, map) do
+        {:ok, value} -> value
+        :error -> nil
+      end
 
     case fun.(current) do
-      {get, update} ->
-        {get, put(map, key, update)}
-
-      :pop ->
-        {current, delete(map, key)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+      {get, update} -> {get, :maps.put(key, update, map)}
+      :pop          -> {current, :maps.remove(key, map)}
     end
   end
 
+  def get_and_update(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Gets the value from `key` and updates it. Raises if there is no `key`.
 
-  Behaves exactly like `get_and_update/3`, but raises a `KeyError` exception if
-  `key` is not present in `map`.
+  This `fun` argument receives the value of `key` and must return a
+  two-element tuple: the "get" value (the retrieved value, which can be
+  operated on before being returned) and the new value to be stored under
+  `key`.
+
+  The returned value is a tuple with the "get" value returned by `fun` and a
+  new map with the updated value under `key`.
 
   ## Examples
 
@@ -816,7 +587,7 @@ defmodule Map do
       iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
       ...>   {current_value, "new value!"}
       ...> end)
-      ** (KeyError) key :b not found in: %{a: 1}
+      ** (KeyError) key :b not found
 
       iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
       ...>   :pop
@@ -824,29 +595,26 @@ defmodule Map do
       {1, %{}}
 
   """
-  @spec get_and_update!(map, key, (value -> {get, value} | :pop)) :: {get, map} | no_return
-        when get: term
-  def get_and_update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-
-    case fun.(value) do
-      {get, update} ->
-        {get, put(map, key, update)}
-
-      :pop ->
-        {value, delete(map, key)}
-
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
+  @spec get_and_update!(map, key, (value -> {get, value})) :: {get, map} | no_return when get: term
+  def get_and_update!(%{} = map, key, fun) do
+    case :maps.find(key, map) do
+      {:ok, value} ->
+        case fun.(value) do
+          {get, update} -> {get, :maps.put(key, update, map)}
+          :pop          -> {value, :maps.remove(key, map)}
+        end
+      :error ->
+        :erlang.error({:badkey, key})
     end
   end
 
+  def get_and_update!(map, _key, _fun), do: :erlang.error({:badmap, map})
+
   @doc """
   Converts a `struct` to map.
 
   It accepts the struct module or a struct itself and
-  simply removes the `__struct__` field from the given struct
-  or from a new struct generated from the given module.
+  simply removes the `__struct__` field from the struct.
 
   ## Example
 
@@ -863,11 +631,11 @@ defmodule Map do
   """
   @spec from_struct(atom | struct) :: map
   def from_struct(struct) when is_atom(struct) do
-    delete(struct.__struct__(), :__struct__)
+    :maps.remove(:__struct__, struct.__struct__)
   end
 
-  def from_struct(%_{} = struct) do
-    delete(struct, :__struct__)
+  def from_struct(%{__struct__: _} = struct) do
+    :maps.remove(:__struct__, struct)
   end
 
   @doc """
@@ -885,16 +653,12 @@ defmodule Map do
 
   """
   @spec equal?(map, map) :: boolean
-  def equal?(map1, map2)
-
   def equal?(%{} = map1, %{} = map2), do: map1 === map2
-  def equal?(%{} = map1, map2), do: :erlang.error({:badmap, map2}, [map1, map2])
-  def equal?(term, other), do: :erlang.error({:badmap, term}, [term, other])
 
   @doc false
   # TODO: Remove on 2.0
-  @deprecated "Use Kernel.map_size/1 instead"
   def size(map) do
+    IO.warn "Map.size/1 is deprecated, please use Kernel.map_size/1"
     map_size(map)
   end
 end

lib/elixir/lib/map_set.ex

@@ -1,55 +1,24 @@
 defmodule MapSet do
   @moduledoc """
-  Functions that work on sets.
+  A set of functions for working with sets.
 
-  `MapSet` is the "go to" set data structure in Elixir. A set can be constructed
-  using `MapSet.new/0`:
-
-      iex> MapSet.new()
-      #MapSet<[]>
-
-  A set can contain any kind of elements, and elements in a set don't have to be
-  of the same type. By definition, sets can't contain duplicate elements: when
-  inserting an element in a set where it's already present, the insertion is
-  simply a no-op.
-
-      iex> map_set = MapSet.new()
-      iex> MapSet.put(map_set, "foo")
-      #MapSet<["foo"]>
-      iex> map_set |> MapSet.put("foo") |> MapSet.put("foo")
-      #MapSet<["foo"]>
-
-  A `MapSet` is represented internally using the `%MapSet{}` struct. This struct
-  can be used whenever there's a need to pattern match on something being a `MapSet`:
-
-      iex> match?(%MapSet{}, MapSet.new())
-      true
-
-  Note that, however, the struct fields are private and must not be accessed
-  directly; use the functions in this module to perform operations on sets.
-
-  `MapSet`s can also be constructed starting from other collection-type data
-  structures: for example, see `MapSet.new/1` or `Enum.into/2`.
+  The `MapSet` is represented internally as a struct,
+  therefore `%MapSet{}` can be used whenever there is a
+  need to match on any `MapSet`. Note though the struct
+  fields are private and must not be accessed directly.
+  Instead, use the functions in this module.
   """
 
-  # MapSets have an underlying Map. MapSet elements are keys of said map,
-  # and this empty list is their associated dummy value.
-  @dummy_value []
-
+  @opaque t :: %__MODULE__{map: map}
   @type value :: term
-
-  @opaque t(value) :: %__MODULE__{map: %{optional(value) => []}}
-  @type t :: t(term)
-
-  # TODO: Remove version key on Elixir 2.0
-  defstruct map: %{}, version: 2
+  defstruct map: %{}
 
   @doc """
   Returns a new set.
 
   ## Examples
 
-      iex> MapSet.new()
+      iex> MapSet.new
       #MapSet<[]>
 
   """
@@ -67,22 +36,19 @@ defmodule MapSet do
       #MapSet<[1, 2, 3]>
 
   """
-  @spec new(Enum.t()) :: t
-  def new(enumerable)
-
-  def new(%__MODULE__{} = map_set), do: map_set
-
+  @spec new(Enum.t) :: t
+  def new(%__MODULE__{} = mapset), do: mapset
   def new(enumerable) do
     map =
       enumerable
-      |> Enum.to_list()
-      |> new_from_list([])
+      |> Enum.to_list
+      |> do_new([])
 
     %MapSet{map: map}
   end
 
   @doc """
-  Creates a set from an enumerable via the transformation function.
+  Creates a mapset from an enumerable via the transformation function.
 
   ## Examples
 
@@ -90,53 +56,55 @@ defmodule MapSet do
       #MapSet<[2, 4]>
 
   """
-  @spec new(Enum.t(), (term -> val)) :: t(val) when val: value
-  def new(enumerable, transform) when is_function(transform, 1) do
+  @spec new(Enum.t, (term -> term)) :: t
+  def new(enumerable, transform) do
     map =
       enumerable
-      |> Enum.to_list()
-      |> new_from_list_transform(transform, [])
+      |> Enum.to_list
+      |> do_new_transform(transform, [])
 
     %MapSet{map: map}
   end
 
-  defp new_from_list([], acc) do
-    :maps.from_list(acc)
+  defp do_new([], acc) do
+    acc
+    |> :lists.reverse
+    |> :maps.from_list
+  end
+  defp do_new([item | rest], acc) do
+    do_new(rest, [{item, true} | acc])
   end
 
-  defp new_from_list([item | rest], acc) do
-    new_from_list(rest, [{item, @dummy_value} | acc])
+  defp do_new_transform([], _fun, acc) do
+    acc
+    |> :lists.reverse
+    |> :maps.from_list
   end
-
-  defp new_from_list_transform([], _fun, acc) do
-    :maps.from_list(acc)
-  end
-
-  defp new_from_list_transform([item | rest], fun, acc) do
-    new_from_list_transform(rest, fun, [{fun.(item), @dummy_value} | acc])
+  defp do_new_transform([item | rest], fun, acc) do
+    do_new_transform(rest, fun, [{fun.(item), true} | acc])
   end
 
   @doc """
-  Deletes `value` from `map_set`.
+  Deletes `value` from `set`.
 
-  Returns a new set which is a copy of `map_set` but without `value`.
+  Returns a new set which is a copy of `set` but without `value`.
 
   ## Examples
 
-      iex> map_set = MapSet.new([1, 2, 3])
-      iex> MapSet.delete(map_set, 4)
+      iex> set = MapSet.new([1, 2, 3])
+      iex> MapSet.delete(set, 4)
       #MapSet<[1, 2, 3]>
-      iex> MapSet.delete(map_set, 2)
+      iex> MapSet.delete(set, 2)
       #MapSet<[1, 3]>
 
   """
-  @spec delete(t(val1), val2) :: t(val1) when val1: value, val2: value
-  def delete(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.delete(map, value)}
+  @spec delete(t, value) :: t
+  def delete(%MapSet{map: map} = set, value) do
+    %{set | map: Map.delete(map, value)}
   end
 
   @doc """
-  Returns a set that is `map_set1` without the members of `map_set2`.
+  Returns a set that is `set1` without the members of `set2`.
 
   ## Examples
 
@@ -144,18 +112,15 @@ defmodule MapSet do
       #MapSet<[1]>
 
   """
-  @spec difference(t(val1), t(val2)) :: t(val1) when val1: value, val2: value
-  def difference(map_set1, map_set2)
-
+  @spec difference(t, t) :: t
   # If the first set is less than twice the size of the second map,
   # it is fastest to re-accumulate items in the first set that are not
   # present in the second set.
   def difference(%MapSet{map: map1}, %MapSet{map: map2})
-      when map_size(map1) < map_size(map2) * 2 do
-    map =
-      map1
-      |> Map.keys()
-      |> filter_not_in(map2, [])
+  when map_size(map1) < map_size(map2) * 2 do
+    map = map1
+    |> Map.keys
+    |> filter_not_in(map2)
 
     %MapSet{map: map}
   end
@@ -163,21 +128,23 @@ defmodule MapSet do
   # If the second set is less than half the size of the first set, it's fastest
   # to simply iterate through each item in the second set, deleting them from
   # the first set.
-  def difference(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
-    %{map_set | map: Map.drop(map1, Map.keys(map2))}
+  def difference(%MapSet{map: map1}, %MapSet{map: map2}) do
+    %MapSet{map: Map.drop(map1, Map.keys(map2))}
   end
 
+  defp filter_not_in(keys, map2, acc \\ [])
   defp filter_not_in([], _map2, acc), do: :maps.from_list(acc)
-
   defp filter_not_in([key | rest], map2, acc) do
-    case map2 do
-      %{^key => _} -> filter_not_in(rest, map2, acc)
-      _ -> filter_not_in(rest, map2, [{key, @dummy_value} | acc])
+    acc = if Map.has_key?(map2, key) do
+      acc
+    else
+      [{key, true} | acc]
     end
+    filter_not_in(rest, map2, acc)
   end
 
   @doc """
-  Checks if `map_set1` and `map_set2` have no members in common.
+  Checks if `set1` and `set2` have no members in common.
 
   ## Examples
 
@@ -192,25 +159,24 @@ defmodule MapSet do
     {map1, map2} = order_by_size(map1, map2)
 
     map1
-    |> Map.keys()
+    |> Map.keys
     |> none_in?(map2)
   end
 
   defp none_in?([], _) do
     true
   end
-
   defp none_in?([key | rest], map2) do
-    case map2 do
-      %{^key => _} -> false
-      _ -> none_in?(rest, map2)
+    case Map.has_key?(map2, key) do
+      true -> false
+      false -> none_in?(rest, map2)
     end
   end
 
   @doc """
   Checks if two sets are equal.
 
-  The comparison between elements must be done using `===/2`.
+  The comparison between elements must be done using `===`.
 
   ## Examples
 
@@ -221,18 +187,12 @@ defmodule MapSet do
 
   """
   @spec equal?(t, t) :: boolean
-  def equal?(%MapSet{map: map1, version: version}, %MapSet{map: map2, version: version}) do
+  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
     Map.equal?(map1, map2)
   end
 
-  # Elixir v1.5 change the map representation, so on
-  # version mismatch we need to compare the keys directly.
-  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map_size(map1) == map_size(map2) and map_subset?(Map.keys(map1), map2)
-  end
-
   @doc """
-  Returns a set containing only members that `map_set1` and `map_set2` have in common.
+  Returns a set containing only members that `set1` and `set2` have in common.
 
   ## Examples
 
@@ -243,14 +203,15 @@ defmodule MapSet do
       #MapSet<[]>
 
   """
-  @spec intersection(t(val), t(val)) :: t(val) when val: value
-  def intersection(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
+  @spec intersection(t, t) :: t
+  def intersection(%MapSet{map: map1}, %MapSet{map: map2}) do
     {map1, map2} = order_by_size(map1, map2)
-    %{map_set | map: Map.take(map2, Map.keys(map1))}
+
+    %MapSet{map: Map.take(map2, Map.keys(map1))}
   end
 
   @doc """
-  Checks if `map_set` contains `value`.
+  Checks if `set` contains `value`.
 
   ## Examples
 
@@ -262,11 +223,11 @@ defmodule MapSet do
   """
   @spec member?(t, value) :: boolean
   def member?(%MapSet{map: map}, value) do
-    match?(%{^value => _}, map)
+    Map.has_key?(map, value)
   end
 
   @doc """
-  Inserts `value` into `map_set` if `map_set` doesn't already contain it.
+  Inserts `value` into `set` if `set` doesn't already contain it.
 
   ## Examples
 
@@ -276,13 +237,13 @@ defmodule MapSet do
       #MapSet<[1, 2, 3, 4]>
 
   """
-  @spec put(t(val), new_val) :: t(val | new_val) when val: value, new_val: value
-  def put(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.put(map, value, @dummy_value)}
+  @spec put(t, value) :: t
+  def put(%MapSet{map: map} = set, value) do
+    %{set | map: Map.put(map, value, true)}
   end
 
   @doc """
-  Returns the number of elements in `map_set`.
+  Returns the number of elements in `set`.
 
   ## Examples
 
@@ -296,9 +257,9 @@ defmodule MapSet do
   end
 
   @doc """
-  Checks if `map_set1`'s members are all contained in `map_set2`.
+  Checks if `set1`'s members are all contained in `set2`.
 
-  This function checks if `map_set1` is a subset of `map_set2`.
+  This function checks if `set1` is a subset of `set2`.
 
   ## Examples
 
@@ -312,21 +273,24 @@ defmodule MapSet do
   def subset?(%MapSet{map: map1}, %MapSet{map: map2}) do
     if map_size(map1) <= map_size(map2) do
       map1
-      |> Map.keys()
-      |> map_subset?(map2)
+      |> Map.keys
+      |> do_subset?(map2)
     else
       false
     end
   end
 
-  defp map_subset?([], _), do: true
-
-  defp map_subset?([key | rest], map2) do
-    match?(%{^key => _}, map2) and map_subset?(rest, map2)
+  defp do_subset?([], _), do: true
+  defp do_subset?([key | rest], map2) do
+    if Map.has_key?(map2, key) do
+      do_subset?(rest, map2)
+    else
+      false
+    end
   end
 
   @doc """
-  Converts `map_set` to a list.
+  Converts `set` to a list.
 
   ## Examples
 
@@ -334,13 +298,13 @@ defmodule MapSet do
       [1, 2, 3]
 
   """
-  @spec to_list(t(val)) :: [val] when val: value
+  @spec to_list(t) :: list
   def to_list(%MapSet{map: map}) do
     Map.keys(map)
   end
 
   @doc """
-  Returns a set containing all members of `map_set1` and `map_set2`.
+  Returns a set containing all members of `set1` and `set2`.
 
   ## Examples
 
@@ -348,57 +312,35 @@ defmodule MapSet do
       #MapSet<[1, 2, 3, 4]>
 
   """
-  @spec union(t(val1), t(val2)) :: t(val1 | val2) when val1: value, val2: value
-  def union(map_set1, map_set2)
-
-  def union(%MapSet{map: map1, version: version} = map_set, %MapSet{map: map2, version: version}) do
-    %{map_set | map: Map.merge(map1, map2)}
-  end
-
+  @spec union(t, t) :: t
   def union(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map = new_from_list(Map.keys(map1) ++ Map.keys(map2), [])
-    %MapSet{map: map}
+    %MapSet{map: Map.merge(map1, map2)}
   end
 
-  @compile {:inline, [order_by_size: 2]}
   defp order_by_size(map1, map2) when map_size(map1) > map_size(map2), do: {map2, map1}
   defp order_by_size(map1, map2), do: {map1, map2}
 
   defimpl Enumerable do
-    def count(map_set) do
-      {:ok, MapSet.size(map_set)}
-    end
-
-    def member?(map_set, val) do
-      {:ok, MapSet.member?(map_set, val)}
-    end
-
-    def slice(map_set) do
-      {:ok, MapSet.size(map_set), &Enumerable.List.slice(MapSet.to_list(map_set), &1, &2)}
-    end
-
-    def reduce(map_set, acc, fun) do
-      Enumerable.List.reduce(MapSet.to_list(map_set), acc, fun)
-    end
+    def reduce(set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(set), acc, fun)
+    def member?(set, val),     do: {:ok, MapSet.member?(set, val)}
+    def count(set),            do: {:ok, MapSet.size(set)}
   end
 
   defimpl Collectable do
-    def into(map_set) do
-      fun = fn
-        list, {:cont, x} -> [{x, []} | list]
-        list, :done -> %{map_set | map: Map.merge(map_set.map, Map.new(list))}
+    def into(original) do
+      {original, fn
+        set, {:cont, x} -> MapSet.put(set, x)
+        set, :done -> set
         _, :halt -> :ok
-      end
-
-      {[], fun}
+      end}
     end
   end
 
   defimpl Inspect do
     import Inspect.Algebra
 
-    def inspect(map_set, opts) do
-      concat(["#MapSet<", Inspect.List.inspect(MapSet.to_list(map_set), opts), ">"])
+    def inspect(set, opts) do
+      concat ["#MapSet<", Inspect.List.inspect(MapSet.to_list(set), opts), ">"]
     end
   end
 end

lib/elixir/lib/module/locals_tracker.ex

@@ -4,203 +4,357 @@
 #
 # ## Implementation
 #
-# The implementation uses ets to track all dependencies
-# resembling a graph. The keys and what they point to are:
+# The implementation uses the digraph module to track
+# all dependencies. The graph starts with one main vertex:
 #
-#   * `:reattach` points to `{name, arity}`
-#   * `{:local, {name, arity}}` points to `{name, arity}`
-#   * `{:import, {name, arity}}` points to `Module`
+# * `:local` - points to local functions
 #
-# This is built on top of the internal module tables.
+# We can also have the following vertices:
+#
+# * `Module` - a module that was invoked via an import
+# * `{name, arity}` - a local function/arity pair
+# * `{:import, name, arity}` - an invoked function/arity import
+#
+# Each of those vertices can associate to other vertices
+# as described below:
+#
+# * `Module`
+#   * in neighbours:  `{:import, name, arity}`
+#
+# * `{name, arity}`
+#   * in neighbours: `:local`, `{name, arity}`
+#   * out neighbours: `{:import, name, arity}`
+#
+# * `{:import, name, arity}`
+#   * in neighbours: `{name, arity}`
+#   * out neighbours: `Module`
+#
+# Note that since this is required for bootstrap, we can't use
+# any of the `GenServer` conveniences.
 defmodule Module.LocalsTracker do
   @moduledoc false
 
+  @timeout   30_000
+  @behaviour :gen_server
+
+  @type ref :: pid | module
+  @type name :: atom
+  @type name_arity :: {name, arity}
+
+  @type local :: {name, arity}
+  @type import :: {:import, name, arity}
+
+  # Public API
+
   @doc """
-  Adds and tracks defaults for a definition into the tracker.
+  Returns all imported modules that had the given
+  `{name, arity}` invoked.
   """
-  def add_defaults({_set, bag}, _kind, {name, arity} = pair, defaults) do
-    for i <- :lists.seq(arity - defaults, arity - 1) do
-      put_edge(bag, {:local, {name, i}}, pair)
-    end
-
-    :ok
+  @spec imports_with_dispatch(ref, name_arity) :: [module]
+  def imports_with_dispatch(ref, {name, arity}) do
+    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
+    :digraph.out_neighbours(d, {:import, name, arity})
   end
 
   @doc """
-  Adds a local dispatch from-to the given target.
-  """
-  def add_local({_set, bag}, from, to) when is_tuple(from) and is_tuple(to) do
-    if from != to do
-      put_edge(bag, {:local, from}, to)
-    end
-
-    :ok
-  end
-
-  @doc """
-  Adds an import dispatch to the given target.
-  """
-  def add_import({set, _bag}, function, module, imported)
-      when is_tuple(function) and is_atom(module) do
-    put_edge(set, {:import, imported}, module)
-    :ok
-  end
-
-  @doc """
-  Yanks a local node. Returns its in and out vertices in a tuple.
-  """
-  def yank({_set, bag}, local) do
-    :lists.usort(take_out_neighbours(bag, {:local, local}))
-  end
-
-  @doc """
-  Reattach a previously yanked node.
-  """
-  def reattach({_set, bag}, tuple, _kind, function, out_neigh) do
-    for to <- out_neigh do
-      put_edge(bag, {:local, function}, to)
-    end
-
-    # Make a call from the old function to the new one
-    if function != tuple do
-      put_edge(bag, {:local, function}, tuple)
-    end
-
-    # Finally marked the new one as reattached
-    put_edge(bag, :reattach, tuple)
-    :ok
-  end
-
-  # Collecting all conflicting imports with the given functions
-  @doc false
-  def collect_imports_conflicts({set, _bag}, all_defined) do
-    for {pair, _, meta, _} <- all_defined, n = out_neighbour(set, {:import, pair}) do
-      {meta, {n, pair}}
-    end
-  end
-
-  @doc """
-  Collect all unused definitions based on the private
-  given, also accounting the expected number of default
-  clauses a private function have.
-  """
-  def collect_unused_locals({_set, bag}, all_defined, private) do
-    reachable =
-      Enum.reduce(all_defined, %{}, fn {pair, kind, _, _}, acc ->
-        if kind in [:def, :defmacro] do
-          reachable_from(bag, pair, acc)
-        else
-          acc
-        end
-      end)
-
-    reattached = :lists.usort(out_neighbours(bag, :reattach))
-    {unreachable(reachable, reattached, private), collect_warnings(reachable, private)}
-  end
-
-  defp unreachable(reachable, reattached, private) do
-    for {tuple, kind, _, _} <- private,
-        not reachable?(tuple, kind, reachable, reattached),
-        do: tuple
-  end
-
-  defp reachable?(tuple, :defmacrop, reachable, reattached) do
-    # All private micros are unreachable unless they have been
-    # reattached and they are reachable.
-    :lists.member(tuple, reattached) and Map.has_key?(reachable, tuple)
-  end
-
-  defp reachable?(tuple, :defp, reachable, _reattached) do
-    Map.has_key?(reachable, tuple)
-  end
-
-  defp collect_warnings(reachable, private) do
-    :lists.foldl(&collect_warnings(&1, &2, reachable), [], private)
-  end
-
-  defp collect_warnings({_, _, false, _}, acc, _reachable) do
-    acc
-  end
-
-  defp collect_warnings({tuple, kind, meta, 0}, acc, reachable) do
-    if Map.has_key?(reachable, tuple) do
-      acc
-    else
-      [{meta, {:unused_def, tuple, kind}} | acc]
-    end
-  end
-
-  defp collect_warnings({tuple, kind, meta, default}, acc, reachable) when default > 0 do
-    {name, arity} = tuple
-    min = arity - default
-    max = arity
-
-    case min_reachable_default(max, min, :none, name, reachable) do
-      :none -> [{meta, {:unused_def, tuple, kind}} | acc]
-      ^min -> acc
-      ^max -> [{meta, {:unused_args, tuple}} | acc]
-      diff -> [{meta, {:unused_args, tuple, diff}} | acc]
-    end
-  end
-
-  defp min_reachable_default(max, min, last, name, reachable) when max >= min do
-    case Map.has_key?(reachable, {name, max}) do
-      true -> min_reachable_default(max - 1, min, max, name, reachable)
-      false -> min_reachable_default(max - 1, min, last, name, reachable)
-    end
-  end
-
-  defp min_reachable_default(_max, _min, last, _name, _reachable) do
-    last
-  end
-
-  @doc """
-  Returns all local nodes reachable from `vertex`.
+  Returns all locals that are reachable.
 
   By default, all public functions are reachable.
   A private function is only reachable if it has
   a public function that it invokes directly.
   """
-  def reachable_from({_, bag}, local) do
-    bag
-    |> reachable_from(local, %{})
-    |> Map.keys()
+  @spec reachable(ref) :: [local]
+  def reachable(ref) do
+    reachable_from(:gen_server.call(to_pid(ref), :digraph, @timeout), :local)
   end
 
-  defp reachable_from(bag, local, vertices) do
-    vertices = Map.put(vertices, local, true)
+  defp reachable_from(d, starting) do
+    :sets.to_list(reduce_reachable(d, starting, :sets.new))
+  end
 
-    Enum.reduce(out_neighbours(bag, {:local, local}), vertices, fn {_, _} = local, acc ->
-      case acc do
-        %{^local => true} -> acc
-        _ -> reachable_from(bag, local, acc)
+  defp reduce_reachable(d, vertex, vertices) do
+    neighbours = :digraph.out_neighbours(d, vertex)
+    neighbours = (for {_, _} = t <- neighbours, do: t) |> :sets.from_list
+    remaining  = :sets.subtract(neighbours, vertices)
+    vertices   = :sets.union(neighbours, vertices)
+    :sets.fold(&reduce_reachable(d, &1, &2), vertices, remaining)
+  end
+
+  defp to_pid(pid) when is_pid(pid),  do: pid
+  defp to_pid(mod) when is_atom(mod) do
+    table = :elixir_module.data_table(mod)
+    [{_, val}] = :ets.lookup(table, {:elixir, :locals_tracker})
+    val
+  end
+
+  # Internal API
+
+  # Starts the tracker and returns its pid.
+  @doc false
+  def start_link do
+    :gen_server.start_link(__MODULE__, [], [])
+  end
+
+  # Adds a definition into the tracker. A public
+  # definition is connected with the :local node
+  # while a private one is left unreachable until
+  # a call is made to.
+  @doc false
+  def add_definition(pid, kind, tuple) when kind in [:def, :defp, :defmacro, :defmacrop] do
+    :gen_server.cast(pid, {:add_definition, kind, tuple})
+  end
+
+  # Adds and tracks defaults for a definition into the tracker.
+  @doc false
+  def add_defaults(pid, kind, tuple, defaults) when kind in [:def, :defp, :defmacro, :defmacrop] do
+    :gen_server.cast(pid, {:add_defaults, kind, tuple, defaults})
+  end
+
+  # Adds a local dispatch to the given target.
+  def add_local(pid, to) when is_tuple(to) do
+    :gen_server.cast(pid, {:add_local, :local, to})
+  end
+
+  # Adds a local dispatch from-to the given target.
+  @doc false
+  def add_local(pid, from, to) when is_tuple(from) and is_tuple(to) do
+    :gen_server.cast(pid, {:add_local, from, to})
+  end
+
+  # Adds an import dispatch to the given target.
+  @doc false
+  def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
+    :gen_server.cast(pid, {:add_import, function, module, target})
+  end
+
+  # Yanks a local node. Returns its in and out vertices in a tuple.
+  @doc false
+  def yank(pid, local) do
+    :gen_server.call(to_pid(pid), {:yank, local}, @timeout)
+  end
+
+  # Reattach a previously yanked node
+  @doc false
+  def reattach(pid, kind, tuple, neighbours) do
+    :gen_server.cast(to_pid(pid), {:reattach, kind, tuple, neighbours})
+  end
+
+  # Collecting all conflicting imports with the given functions
+  @doc false
+  def collect_imports_conflicts(pid, all_defined) do
+    d = :gen_server.call(pid, :digraph, @timeout)
+
+    for {name, arity} <- all_defined,
+        :digraph.in_neighbours(d, {:import, name, arity}) != [],
+        n = :digraph.out_neighbours(d, {:import, name, arity}),
+        n != [] do
+      {n, name, arity}
+    end
+  end
+
+  # Collect all unused definitions based on the private
+  # given also accounting the expected amount of default
+  # clauses a private function have.
+  @doc false
+  def collect_unused_locals(ref, private) do
+    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
+    {unreachable(d, private), collect_warnings(d, private)}
+  end
+
+  defp unreachable(d, private) do
+    unreachable = for {tuple, _, _} <- private, do: tuple
+
+    private =
+      for {tuple, :defp, _} <- private do
+        neighbours = :digraph.in_neighbours(d, tuple)
+        neighbours = for {_, _} = t <- neighbours, do: t
+        {tuple, :sets.from_list(neighbours)}
       end
-    end)
+
+    reduce_unreachable(private, [], :sets.from_list(unreachable))
   end
 
-  ## Lightweight digraph implementation
-
-  defp put_edge(d, from, to) do
-    :ets.insert(d, {from, to})
-  end
-
-  defp out_neighbour(d, from) do
-    try do
-      :ets.lookup_element(d, from, 2)
-    catch
-      :error, :badarg -> nil
+  defp reduce_unreachable([{vertex, callers} | t], acc, unreachable) do
+    if :sets.is_subset(callers, unreachable) do
+      reduce_unreachable(t, [{vertex, callers} | acc], unreachable)
+    else
+      reduce_unreachable(acc ++ t, [], :sets.del_element(vertex, unreachable))
     end
   end
 
-  defp out_neighbours(d, from) do
-    try do
-      :ets.lookup_element(d, from, 2)
-    catch
-      :error, :badarg -> []
+  defp reduce_unreachable([], _acc, unreachable) do
+    :sets.to_list(unreachable)
+  end
+
+  defp collect_warnings(d, private) do
+    reachable = reachable_from(d, :local)
+    :lists.foldl(&collect_warnings(&1, &2, reachable), [], private)
+  end
+
+  defp collect_warnings({tuple, kind, 0}, acc, reachable) do
+    if :lists.member(tuple, reachable) do
+      acc
+    else
+      [{:unused_def, tuple, kind} | acc]
     end
   end
 
-  defp take_out_neighbours(d, from) do
-    Keyword.values(:ets.take(d, from))
+  defp collect_warnings({tuple, kind, default}, acc, reachable) when default > 0 do
+    {name, arity} = tuple
+    min = arity - default
+    max = arity
+
+    invoked = for {n, a} <- reachable, n == name, a in min..max, do: a
+
+    if invoked == [] do
+      [{:unused_def, tuple, kind} | acc]
+    else
+      case :lists.min(invoked) - min do
+        0 -> acc
+        ^default -> [{:unused_args, tuple} | acc]
+        unused_args -> [{:unused_args, tuple, unused_args} | acc]
+      end
+    end
+  end
+
+  @doc false
+  def cache_env(pid, env) do
+    :gen_server.call(pid, {:cache_env, env}, @timeout)
+  end
+
+  @doc false
+  def get_cached_env(pid, ref) do
+    :gen_server.call(pid, {:get_cached_env, ref}, @timeout)
+  end
+
+  # Stops the gen server
+  @doc false
+  def stop(pid) do
+    :gen_server.cast(pid, :stop)
+  end
+
+  # Callbacks
+
+  def init([]) do
+    d = :digraph.new([:protected])
+    :digraph.add_vertex(d, :local)
+    {:ok, {d, []}}
+  end
+
+  @doc false
+  def handle_call({:cache_env, env}, _from, {d, cache}) do
+    case cache do
+      [{i, ^env} | _] ->
+        {:reply, i, {d, cache}}
+      t ->
+        i = length(t)
+        {:reply, i, {d, [{i, env} | t]}}
+    end
+  end
+
+  def handle_call({:get_cached_env, ref}, _from, {_, cache} = state) do
+    {^ref, env} = :lists.keyfind(ref, 1, cache)
+    {:reply, env, state}
+  end
+
+  def handle_call({:yank, local}, _from, {d, _} = state) do
+    out_vertices = :digraph.out_neighbours(d, local)
+    :digraph.del_edges(d, :digraph.out_edges(d, local))
+    {:reply, {[], out_vertices}, state}
+  end
+
+  def handle_call(:digraph, _from, {d, _} = state) do
+    {:reply, d, state}
+  end
+
+  @doc false
+  def handle_info(_msg, state) do
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_local, from, to}, {d, _} = state) do
+    handle_add_local(d, from, to)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_import, function, module, {name, arity}}, {d, _} = state) do
+    handle_import(d, function, module, name, arity)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_definition, kind, tuple}, {d, _} = state) do
+    handle_add_definition(d, kind, tuple)
+    {:noreply, state}
+  end
+
+  def handle_cast({:add_defaults, kind, {name, arity}, defaults}, {d, _} = state) do
+    for i <- :lists.seq(arity - defaults, arity - 1) do
+      handle_add_definition(d, kind, {name, i})
+      handle_add_local(d, {name, i}, {name, i + 1})
+    end
+    {:noreply, state}
+  end
+
+  def handle_cast({:reattach, _kind, tuple, {in_neigh, out_neigh}}, {d, _} = state) do
+    for from <- in_neigh do
+      :digraph.add_vertex(d, from)
+      replace_edge!(d, from, tuple)
+    end
+
+    for to <- out_neigh do
+      :digraph.add_vertex(d, to)
+      replace_edge!(d, tuple, to)
+    end
+
+    {:noreply, state}
+  end
+
+  def handle_cast(:stop, state) do
+    {:stop, :normal, state}
+  end
+
+  @doc false
+  def terminate(_reason, _state) do
+    :ok
+  end
+
+  @doc false
+  def code_change(_old, state, _extra) do
+    {:ok, state}
+  end
+
+  defp handle_import(d, function, module, name, arity) do
+    :digraph.add_vertex(d, module)
+
+    tuple = {:import, name, arity}
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, tuple, module)
+
+    if function != nil do
+      replace_edge!(d, function, tuple)
+    end
+
+    :ok
+  end
+
+  defp handle_add_local(d, from, to) do
+    :digraph.add_vertex(d, to)
+    replace_edge!(d, from, to)
+  end
+
+  defp handle_add_definition(d, public, tuple) when public in [:def, :defmacro] do
+    :digraph.add_vertex(d, tuple)
+    replace_edge!(d, :local, tuple)
+  end
+
+  defp handle_add_definition(d, private, tuple) when private in [:defp, :defmacrop] do
+    :digraph.add_vertex(d, tuple)
+  end
+
+  defp replace_edge!(d, from, to) do
+    _ = unless :lists.member(to, :digraph.out_neighbours(d, from)) do
+      [:"$e" | _] = :digraph.add_edge(d, from, to)
+    end
+    :ok
   end
 end

lib/elixir/lib/node.ex

@@ -16,7 +16,8 @@ defmodule Node do
   This functionality starts the `:net_kernel` and other
   related processes.
   """
-  @spec start(node, :longnames | :shortnames, non_neg_integer) :: {:ok, pid} | {:error, term}
+  @spec start(node, :longnames | :shortnames, non_neg_integer) ::
+             {:ok, pid} | {:error, term}
   def start(name, type \\ :longnames, tick_time \\ 15000) do
     :net_kernel.start([name, type, tick_time])
   end
@@ -59,8 +60,6 @@ defmodule Node do
   the local node.
 
   Same as `list(:visible)`.
-
-  Inlined by the compiler.
   """
   @spec list :: [t]
   def list do
@@ -73,11 +72,10 @@ defmodule Node do
   The result returned when the argument is a list, is the list of nodes
   satisfying the disjunction(s) of the list elements.
 
-  For more information, see `:erlang.nodes/1`.
-
-  Inlined by the compiler.
+  For more information, see
+  [`:erlang.nodes/1`](http://www.erlang.org/doc/man/erlang.html#nodes-1).
   """
-  @type state :: :visible | :hidden | :connected | :this | :known
+  @typep state :: :visible | :hidden | :connected | :this | :known
   @spec list(state | [state]) :: [t]
   def list(args) do
     :erlang.nodes(args)
@@ -89,9 +87,8 @@ defmodule Node do
   If `flag` is `true`, monitoring is turned on.
   If `flag` is `false`, monitoring is turned off.
 
-  For more information, see `:erlang.monitor_node/2`.
-
-  For monitoring status changes of all nodes, see `:net_kernel.monitor_nodes/3`.
+  For more information, see
+  [`:erlang.monitor_node/2`](http://www.erlang.org/doc/man/erlang.html#monitor_node-2).
   """
   @spec monitor(t, boolean) :: true
   def monitor(node, flag) do
@@ -102,9 +99,8 @@ defmodule Node do
   Behaves as `monitor/2` except that it allows an extra
   option to be given, namely `:allow_passive_connect`.
 
-  For more information, see `:erlang.monitor_node/3`.
-
-  For monitoring status changes of all nodes, see `:net_kernel.monitor_nodes/3`.
+  For more information, see
+  [`:erlang.monitor_node/3`](http://www.erlang.org/doc/man/erlang.html#monitor_node-3).
   """
   @spec monitor(t, boolean, [:allow_passive_connect]) :: true
   def monitor(node, flag, options) do
@@ -135,7 +131,8 @@ defmodule Node do
   protocols. Returns `true` if disconnection succeeds, otherwise `false`.
   If the local node is not alive, the function returns `:ignored`.
 
-  For more information, see `:erlang.disconnect_node/1`.
+  For more information, see
+  [`:erlang.disconnect_node/1`](http://www.erlang.org/doc/man/erlang.html#disconnect_node-1).
   """
   @spec disconnect(t) :: boolean | :ignored
   def disconnect(node) do
@@ -148,7 +145,8 @@ defmodule Node do
   Returns `true` if successful, `false` if not, and the atom
   `:ignored` if the local node is not alive.
 
-  For more information, see `:net_kernel.connect_node/1`.
+  For more information, see
+  [`:erlang.connect_node/1`](http://www.erlang.org/doc/man/net_kernel.html#connect_node-1).
   """
   @spec connect(t) :: boolean | :ignored
   def connect(node) do
@@ -156,10 +154,11 @@ defmodule Node do
   end
 
   @doc """
-  Returns the PID of a new process started by the application of `fun`
-  on `node`. If `node` does not exist, a useless PID is returned.
+  Returns the pid of a new process started by the application of `fun`
+  on `node`. If `node` does not exist, a useless pid is returned.
 
-  For the list of available options, see `:erlang.spawn/2`.
+  For the list of available options, see
+  [`:erlang.spawn/2`](http://www.erlang.org/doc/man/erlang.html#spawn-2).
 
   Inlined by the compiler.
   """
@@ -169,27 +168,29 @@ defmodule Node do
   end
 
   @doc """
-  Returns the PID of a new process started by the application of `fun`
+  Returns the pid of a new process started by the application of `fun`
   on `node`.
 
-  If `node` does not exist, a useless PID is returned.
+  If `node` does not exist, a useless pid is returned.
 
-  For the list of available options, see `:erlang.spawn_opt/3`.
+  For the list of available options, see
+  [`:erlang.spawn_opt/3`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-3).
 
   Inlined by the compiler.
   """
-  @spec spawn(t, (() -> any), Process.spawn_opts()) :: pid | {pid, reference}
+  @spec spawn(t, (() -> any), Process.spawn_opts) :: pid | {pid, reference}
   def spawn(node, fun, opts) do
     :erlang.spawn_opt(node, fun, opts)
   end
 
   @doc """
-  Returns the PID of a new process started by the application of
+  Returns the pid of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless PID is returned.
+  If `node` does not exist, a useless pid is returned.
 
-  For the list of available options, see `:erlang.spawn/4`.
+  For the list of available options, see
+  [`:erlang.spawn/4`](http://www.erlang.org/doc/man/erlang.html#spawn-4).
 
   Inlined by the compiler.
   """
@@ -199,25 +200,26 @@ defmodule Node do
   end
 
   @doc """
-  Returns the PID of a new process started by the application of
+  Returns the pid of a new process started by the application of
   `module.function(args)` on `node`.
 
-  If `node` does not exist, a useless PID is returned.
+  If `node` does not exist, a useless pid is returned.
 
-  For the list of available options, see `:erlang.spawn/5`.
+  For the list of available options, see
+  [`:erlang.spawn/5`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-5).
 
   Inlined by the compiler.
   """
-  @spec spawn(t, module, atom, [any], Process.spawn_opts()) :: pid | {pid, reference}
+  @spec spawn(t, module, atom, [any], Process.spawn_opts) :: pid | {pid, reference}
   def spawn(node, module, fun, args, opts) do
     :erlang.spawn_opt(node, module, fun, args, opts)
   end
 
   @doc """
-  Returns the PID of a new linked process started by the application of `fun` on `node`.
+  Returns the pid of a new linked process started by the application of `fun` on `node`.
 
   A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless PID is returned (and due to the link, an exit
+  If `node` does not exist, a useless pid is returned (and due to the link, an exit
   signal with exit reason `:noconnection` will be received).
 
   Inlined by the compiler.
@@ -228,11 +230,11 @@ defmodule Node do
   end
 
   @doc """
-  Returns the PID of a new linked process started by the application of
+  Returns the pid of a new linked process started by the application of
   `module.function(args)` on `node`.
 
   A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless PID is returned (and due to the link, an exit
+  If `node` does not exist, a useless pid is returned (and due to the link, an exit
   signal with exit reason `:noconnection` will be received).
 
   Inlined by the compiler.
@@ -250,7 +252,7 @@ defmodule Node do
 
   This function will raise `FunctionClauseError` if the given `node` is not alive.
   """
-  def set_cookie(node \\ Node.self(), cookie) when is_atom(cookie) do
+  def set_cookie(node \\ Node.self, cookie) when is_atom(cookie) do
     :erlang.set_cookie(node, cookie)
   end
 

lib/elixir/lib/option_parser.ex

@@ -3,164 +3,94 @@ defmodule OptionParser do
   This module contains functions to parse command line options.
   """
 
-  @type argv :: [String.t()]
-  @type parsed :: keyword
-  @type errors :: [{String.t(), String.t() | nil}]
-  @type options :: [switches: keyword, strict: keyword, aliases: keyword]
+  @type argv    :: [String.t]
+  @type parsed  :: Keyword.t
+  @type errors  :: [{String.t, String.t | nil}]
+  @type options :: [switches: Keyword.t, strict: Keyword.t, aliases: Keyword.t]
 
   defmodule ParseError do
     defexception [:message]
   end
 
   @doc """
-  Parses `argv` into a keyword list.
+  Parses `argv` into a keywords list.
 
-  It returns a three-element tuple with the form `{parsed, args, invalid}`, where:
+  It returns a three-element tuple as follows:
 
-    * `parsed` is a keyword list of parsed switches with `{switch_name, value}`
-      tuples in it; `switch_name` is the atom representing the switch name while
-      `value` is the value for that switch parsed according to `opts` (see the
-      "Examples" section for more information)
-    * `args` is a list of the remaining arguments in `argv` as strings
-    * `invalid` is a list of invalid options as `{option_name, value}` where
-      `option_name` is the raw option and `value` is `nil` if the option wasn't
-      expected or the string value if the value didn't have the expected type for
-      the corresponding option
+     1. parsed switches,
+     2. remaining arguments,
+     3. invalid options.
 
-  Elixir converts switches to underscored atoms, so `--source-path` becomes
-  `:source_path`. This is done to better suit Elixir conventions. However, this
-  means that switches can't contain underscores and switches that do contain
-  underscores are always returned in the list of invalid switches.
+  ## Examples
 
-  When parsing, it is common to list switches and their expected types:
-
-      iex> OptionParser.parse(["--debug"], strict: [debug: :boolean])
+      iex> OptionParser.parse(["--debug"])
       {[debug: true], [], []}
 
-      iex> OptionParser.parse(["--source", "lib"], strict: [source: :string])
+      iex> OptionParser.parse(["--source", "lib"])
       {[source: "lib"], [], []}
 
-      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                    strict: [source_path: :string, verbose: :boolean])
+      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"])
       {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
 
-  We will explore the valid switches and operation modes of option parser below.
+  By default, Elixir will try to automatically parse all switches.
+  Switches followed by a value will be assigned the value, as a string.
+  Switches without an argument, like `--debug` will automatically
+  be set to `true`.
 
-  ## Options
+  Note: Elixir also converts the switches to underscore atoms, so
+  `--source-path` becomes `:source_path`, to better suit Elixir
+  conventions. This means that option names on the command line cannot
+  contain underscores; such options will be put in the invalid options
+  list.
 
-  The following options are supported:
+  ## Switch Definitions
 
-    * `:switches` or `:strict` - see the "Switch definitions" section below
-    * `:allow_nonexistent_atoms` - see the "Parsing unknown switches" section below
-    * `:aliases` - see the "Aliases" section below
+  Often it is better to explicitly list the known
+  switches and their formats. The switches can be specified via two
+  alternative options:
 
-  ## Switch definitions
+    * `:switches` - defines some switches. An attempt is still made to parse
+      switches that do not appear in the list.
 
-  Switches can be specified via one of two options:
+    * `:strict` - the switches are strict. Any switch that is not specified
+      in the list is returned in the invalid options list.
 
-    * `:strict` - defines strict switches. Any switch in `argv` that is not
-      specified in the list is returned in the invalid options list.
-    * `:switches` - defines some switches and their types. This function
-      still attempts to parse switches that are not in this list.
-
-  Both these options accept a keyword list of `{name, type}` tuples where `name`
-  is an atom defining the name of the switch and `type` is an atom that
-  specifies the type for the value of this switch (see the "Types" section below
-  for the possible types and more information about type casting).
-
-  Note that you should only supply the `:switches` or the `:strict` option.
-  If you supply both, an `ArgumentError` exception will be raised.
+  Note that you should only supply the `:switches` or `:strict` option.
+  If you supply both, an error will be raised.
 
   ### Types
 
-  Switches parsed by `OptionParser` may take zero or one arguments.
+  Option parser switches may take 0 or 1 argument.
 
-  The following switches types take no arguments:
+  The following switches take no argument:
 
-    * `:boolean` - sets the value to `true` when given (see also the
-      "Negation switches" section below)
-    * `:count` - counts the number of times the switch is given
+    * `:boolean` - sets the value to true when given
+    * `:count`   - counts the number of times the switch is given
 
-  The following switches take one argument:
+  The following switches take 1 argument:
 
-    * `:integer` - parses the value as an integer
-    * `:float` - parses the value as a float
-    * `:string` - parses the value as a string
+    * `:integer` - parses the upcoming value as an integer.
+    * `:float`   - parses the upcoming value as a float.
+    * `:string`  - parses the upcoming value as a string.
 
-  If a switch can't be parsed according to the given type, it is
-  returned in the invalid options list.
+  If a switch can't be parsed, it is returned in the invalid
+  options list.
 
   ### Modifiers
 
   Switches can be specified with modifiers, which change how
   they behave. The following modifiers are supported:
 
-    * `:keep` - keeps duplicated items instead of overriding them;
-      works with all types except `:count`. Specifying `switch_name: :keep`
-      assumes the type of `:switch_name` will be `:string`.
+    * `:keep` - keeps duplicated items instead of overriding them.
+      Works with all types except `:count`.
 
-  To use `:keep` with a type other than `:string`, use a list as the type
-  for the switch. For example: `[foo: [:integer, :keep]]`.
+  Note: if you want to use `:keep` with a non-string type, use a list, e.g.
+  `[foo: [:integer, :keep]]`.
 
-  ### Negation switches
+  ### Examples
 
-  In case a switch `SWITCH` is specified to have type `:boolean`, it may be
-  passed as `--no-SWITCH` as well which will set the option to `false`:
-
-      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
-      {[op: false], ["path/to/file"], []}
-
-  ### Parsing unknown switches
-
-  When the `:switches` option is given, `OptionParser` will attempt to parse
-  unknown switches:
-
-      iex> OptionParser.parse(["--debug"], switches: [key: :string])
-      {[debug: true], [], []}
-
-  Even though we haven't specified `--debug` in the list of switches, it is part
-  of the returned options. This would also work:
-
-      iex> OptionParser.parse(["--debug", "value"], switches: [key: :string])
-      {[debug: "value"], [], []}
-
-  Switches followed by a value will be assigned the value, as a string. Switches
-  without an argument will be set automatically to `true`. Since we cannot assert
-  the type of the switch value, it is preferred to use the `:strict` option that
-  accepts only known switches and always verify their types.
-
-  If you do want to parse unknown switches, remember that Elixir converts switches
-  to atoms. Since atoms are not garbage-collected, OptionParser will only parse
-  switches that translate to atoms used by the runtime to avoid leaking atoms.
-  For instance, the code below will discard the `--option-parser-example` switch
-  because the `:option_parser_example` atom is never used anywhere:
-
-      OptionParser.parse(["--option-parser-example"], switches: [debug: :boolean])
-      # The :option_parser_example atom is not used anywhere below
-
-  However, the code below would work as long as `:option_parser_example` atom is
-  used at some point later (or earlier) **in the same module**:
-
-      {opts, _, _} = OptionParser.parse(["--option-parser-example"], switches: [debug: :boolean])
-      opts[:option_parser_example]
-
-  In other words, Elixir will do the correct thing and only parse options that are
-  used by the runtime, ignoring all others. If you would like to parse all switches,
-  regardless if they exist or not, you can force creation of atoms by passing
-  `allow_nonexistent_atoms: true` as option. Use this option with care. It is only
-  useful when you are building command-line applications that receive
-  dynamically-named arguments and must be avoided in long-running systems.
-
-  ## Aliases
-
-  A set of aliases can be specified in the `:aliases` option:
-
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug], strict: [debug: :boolean])
-      {[debug: true], [], []}
-
-  ## Examples
-
-  Here are some examples of working with different types and modifiers:
+  Here are some examples of option parser working with different types
+  and modifiers:
 
       iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
       {[unlock: true], ["path/to/file"], []}
@@ -191,26 +121,39 @@ defmodule OptionParser do
       iex> OptionParser.parse(["--unlock", "path/to/file", "--unlock", "path/to/another/file"], strict: [unlock: :keep])
       {[unlock: "path/to/file", unlock: "path/to/another/file"], [], []}
 
+  ### Negation switches
+
+  In case a switch is declared as boolean, it may be passed as `--no-SWITCH`
+  which will set the option to `false`:
+
+      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
+      {[op: false], ["path/to/file"], []}
+
+  ## Aliases
+
+  A set of aliases can be given as options too:
+
+      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
+      {[debug: true], [], []}
+
   """
   @spec parse(argv, options) :: {parsed, argv, errors}
   def parse(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    do_parse(argv, build_config(opts), [], [], [], true)
+    do_parse(argv, compile_config(opts), [], [], [], true)
   end
 
   @doc """
   The same as `parse/2` but raises an `OptionParser.ParseError`
   exception if any invalid options are given.
 
-  If there are no errors, returns a `{parsed, rest}` tuple where:
+  If there weren't any errors, returns a three-element tuple as follows:
 
-    * `parsed` is the list of parsed switches (same as in `parse/2`)
-    * `rest` is the list of arguments (same as in `parse/2`)
+      1. parsed options,
+      2. remaining arguments,
+      3. empty list.
 
   ## Examples
 
-      iex> OptionParser.parse!(["--debug", "path/to/file"], strict: [debug: :boolean])
-      {[debug: true], ["path/to/file"]}
-
       iex> OptionParser.parse!(["--limit", "xyz"], strict: [limit: :integer])
       ** (OptionParser.ParseError) 1 error found!
       --limit : Expected type integer, got "xyz"
@@ -229,7 +172,7 @@ defmodule OptionParser do
   @spec parse!(argv, options) :: {parsed, argv} | no_return
   def parse!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
     case parse(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
+      {parsed, argv, []} -> {parsed, argv}
       {_, _, errors} -> raise ParseError, format_errors(errors, opts)
     end
   end
@@ -242,37 +185,31 @@ defmodule OptionParser do
 
   ## Example
 
-      iex> OptionParser.parse_head(["--source", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                         switches: [source: :string, verbose: :boolean])
+      iex> OptionParser.parse_head(["--source", "lib", "test/enum_test.exs", "--verbose"])
       {[source: "lib"], ["test/enum_test.exs", "--verbose"], []}
 
-      iex> OptionParser.parse_head(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
-      ...>                         switches: [source: :string, verbose: :boolean, unlock: :boolean])
+      iex> OptionParser.parse_head(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"])
       {[verbose: true, source: "lib"], ["test/enum_test.exs", "--unlock"], []}
 
   """
   @spec parse_head(argv, options) :: {parsed, argv, errors}
   def parse_head(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    do_parse(argv, build_config(opts), [], [], [], false)
+    do_parse(argv, compile_config(opts), [], [], [], false)
   end
 
   @doc """
   The same as `parse_head/2` but raises an `OptionParser.ParseError`
   exception if any invalid options are given.
 
-  If there are no errors, returns a `{parsed, rest}` tuple where:
+  If there weren't any errors, returns a three-element tuple as follows:
 
-    * `parsed` is the list of parsed switches (same as in `parse_head/2`)
-    * `rest` is the list of arguments (same as in `parse_head/2`)
+      1. parsed options,
+      2. remaining arguments,
+      3. empty list.
 
   ## Examples
 
-      iex> OptionParser.parse_head!(["--source", "lib", "path/to/file", "--verbose"],
-      ...>                         switches: [source: :string, verbose: :boolean])
-      {[source: "lib"], ["path/to/file", "--verbose"]}
-
-      iex> OptionParser.parse_head!(["--number", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                          strict: [number: :integer])
+      iex> OptionParser.parse_head!(["--number", "lib", "test/enum_test.exs", "--verbose"], strict: [number: :integer])
       ** (OptionParser.ParseError) 1 error found!
       --number : Expected type integer, got "lib"
 
@@ -281,12 +218,11 @@ defmodule OptionParser do
       ** (OptionParser.ParseError) 2 errors found!
       --verbose : Missing argument of type integer
       --source : Expected type integer, got "lib"
-
   """
-  @spec parse_head!(argv, options) :: {parsed, argv} | no_return
+  @spec parse_head!(argv, options) :: {parsed, argv, errors} | no_return
   def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
     case parse_head(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
+      {parsed, argv, []} -> {parsed, argv}
       {_, _, errors} -> raise ParseError, format_errors(errors, opts)
     end
   end
@@ -295,12 +231,12 @@ defmodule OptionParser do
     {Enum.reverse(opts), Enum.reverse(args), Enum.reverse(invalid)}
   end
 
-  defp do_parse(argv, %{switches: switches} = config, opts, args, invalid, all?) do
-    case next_with_config(argv, config) do
+  defp do_parse(argv, {aliases, switches, strict}=config, opts, args, invalid, all?) do
+    case next(argv, aliases, switches, strict) do
       {:ok, option, value, rest} ->
         # the option exists and it was successfully parsed
-        kinds = List.wrap(Keyword.get(switches, option))
-        new_opts = store_option(opts, option, value, kinds)
+        kinds = List.wrap Keyword.get(switches, option)
+        new_opts = do_store_option(opts, option, value, kinds)
         do_parse(rest, config, new_opts, args, invalid, all?)
 
       {:invalid, option, value, rest} ->
@@ -308,13 +244,13 @@ defmodule OptionParser do
         do_parse(rest, config, opts, args, [{option, value} | invalid], all?)
 
       {:undefined, option, _value, rest} ->
-        invalid = if config.strict?, do: [{option, nil} | invalid], else: invalid
-        do_parse(rest, config, opts, args, invalid, all?)
+        # the option does not exist (for strict cases)
+        do_parse(rest, config, opts, args, [{option, nil} | invalid], all?)
 
       {:error, ["--" | rest]} ->
         {Enum.reverse(opts), Enum.reverse(args, rest), Enum.reverse(invalid)}
 
-      {:error, [arg | rest] = remaining_args} ->
+      {:error, [arg | rest]=remaining_args} ->
         # there is no option
         if all? do
           do_parse(rest, config, opts, [arg | args], invalid, all?)
@@ -328,172 +264,105 @@ defmodule OptionParser do
   Low-level function that parses one option.
 
   It accepts the same options as `parse/2` and `parse_head/2`
-  as both functions are built on top of this function. This function
+  as both functions are built on top of next. This function
   may return:
 
     * `{:ok, key, value, rest}` - the option `key` with `value` was
       successfully parsed
 
     * `{:invalid, key, value, rest}` - the option `key` is invalid with `value`
-      (returned when the value cannot be parsed according to the switch type)
+      (returned when the switch type does not match the one given via the
+      command line)
 
     * `{:undefined, key, value, rest}` - the option `key` is undefined
-      (returned in strict mode when the switch is unknown or on nonexistent atoms)
-
-    * `{:error, rest}` - there are no switches at the head of the given `argv`
+      (returned in strict mode when the switch is unknown)
 
+    * `{:error, rest}` - there are no switches at the top of the given argv
   """
+
   @spec next(argv, options) ::
-          {:ok, key :: atom, value :: term, argv}
-          | {:invalid, String.t(), String.t() | nil, argv}
-          | {:undefined, String.t(), String.t() | nil, argv}
-          | {:error, argv}
+        {:ok, key :: atom, value :: term, argv} |
+        {:invalid, String.t, String.t | nil, argv} |
+        {:undefined, String.t, String.t | nil, argv} |
+        {:error, argv}
 
   def next(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    next_with_config(argv, build_config(opts))
+    {aliases, switches, strict} = compile_config(opts)
+    next(argv, aliases, switches, strict)
   end
 
-  defp next_with_config([], _config) do
+  defp next([], _aliases, _switches, _strict) do
     {:error, []}
   end
 
-  defp next_with_config(["--" | _] = argv, _config) do
+  defp next(["--" | _]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next_with_config(["-" | _] = argv, _config) do
+  defp next(["-" | _]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next_with_config(["- " <> _ | _] = argv, _config) do
+  defp next(["- " <> _ | _]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  # Handles --foo or --foo=bar
-  defp next_with_config(["--" <> option | rest], config) do
-    {option, value} = split_option(option)
-
-    if String.contains?(option, ["_"]) do
-      {:undefined, "--" <> option, value, rest}
-    else
-      tagged = tag_option(option, config)
-      next_tagged(tagged, value, "--" <> option, rest, config)
-    end
-  end
-
-  # Handles -a, -abc, -abc=something
-  defp next_with_config(["-" <> option | rest] = argv, config) do
-    %{allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
+  defp next(["-" <> option | rest] = argv, aliases, switches, strict) do
     {option, value} = split_option(option)
     original = "-" <> option
-    letters = String.graphemes(option)
+    tagged = tag_option(option, switches, aliases)
 
     cond do
-      is_nil(value) and negative_number?(original) ->
+      negative_number?(original) ->
         {:error, argv}
-
-      String.contains?(option, ["-", "_"]) ->
+      strict and not option_defined?(tagged, switches) ->
         {:undefined, original, value, rest}
-
-      tl(letters) == [] ->
-        # We have a regular one-letter alias here
-        tagged = tag_oneletter_alias(option, config)
-        next_tagged(tagged, value, original, rest, config)
-
       true ->
-        key = get_option_key(option, allow_nonexistent_atoms?)
-        option_key = config.aliases[key]
-
-        if key && option_key do
-          # TODO: Remove this in Elixir v2.0
-          IO.warn("multi-letter aliases are deprecated, got: #{inspect(key)}")
-          next_tagged({:default, option_key}, value, original, rest, config)
-        else
-          next_with_config(expand_multiletter_alias(letters, value) ++ rest, config)
+        {option, kinds, value} = normalize_option(tagged, value, switches)
+        {value, kinds, rest} = normalize_value(value, kinds, rest, strict)
+        case validate_option(value, kinds) do
+          {:ok, new_value} -> {:ok, option, new_value, rest}
+          :invalid         -> {:invalid, original, value, rest}
         end
     end
   end
 
-  defp next_with_config(argv, _config) do
+  defp next(argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next_tagged(:unknown, value, original, rest, _) do
-    {value, _kinds, rest} = normalize_value(value, [], rest)
-    {:undefined, original, value, rest}
-  end
-
-  defp next_tagged({tag, option}, value, original, rest, %{switches: switches, strict?: strict?}) do
-    if strict? and not Keyword.has_key?(switches, option) do
-      {:undefined, original, value, rest}
-    else
-      {kinds, value} = normalize_tag(tag, option, value, switches)
-      {value, kinds, rest} = normalize_value(value, kinds, rest)
-
-      case validate_option(value, kinds) do
-        {:ok, new_value} -> {:ok, option, new_value, rest}
-        :invalid -> {:invalid, original, value, rest}
-      end
-    end
-  end
-
   @doc """
-  Receives a key-value enumerable and converts it to `t:argv/0`.
+  Receives a key-value enumerable and converts it to argv.
 
-  Keys must be atoms. Keys with `nil` value are discarded,
+  Keys must be atoms. Keys with nil value are discarded,
   boolean values are converted to `--key` or `--no-key`
-  (if the value is `true` or `false`, respectively),
-  and all other values are converted using `Kernel.to_string/1`.
-
-  It is advised to pass to `to_argv/2` the same set of `options`
-  given to `parse/2`. Some switches can only be reconstructed
-  correctly with the `switches` information in hand.
+  and all other values are converted using `to_string/1`.
 
   ## Examples
 
-      iex> OptionParser.to_argv(foo_bar: "baz")
+      iex>  OptionParser.to_argv([foo_bar: "baz"])
       ["--foo-bar", "baz"]
-      iex> OptionParser.to_argv(bool: true, bool: false, discarded: nil)
+
+      iex>  OptionParser.to_argv([bool: true, bool: false, discarded: nil])
       ["--bool", "--no-bool"]
 
-  Some switches will output different values based on the switches
-  flag:
-
-      iex> OptionParser.to_argv([number: 2], switches: [])
-      ["--number", "2"]
-      iex> OptionParser.to_argv([number: 2], switches: [number: :count])
-      ["--number", "--number"]
-
   """
-  @spec to_argv(Enumerable.t(), options) :: argv
-  def to_argv(enum, opts \\ []) do
-    switches = Keyword.get(opts, :switches, [])
-
+  @spec to_argv(Enumerable.t) :: argv
+  def to_argv(enum) do
     Enum.flat_map(enum, fn
-      {_key, nil} -> []
-      {key, true} -> [to_switch(key)]
+      {_key, nil}  -> []
+      {key, true}  -> [to_switch(key)]
       {key, false} -> [to_switch(key, "--no-")]
-      {key, value} -> to_argv(key, value, switches)
+      {key, value} -> [to_switch(key), to_string(value)]
     end)
   end
 
-  defp to_argv(key, value, switches) do
-    if switches[key] == :count do
-      List.duplicate(to_switch(key), value)
-    else
-      [to_switch(key), to_string(value)]
-    end
-  end
-
   defp to_switch(key, prefix \\ "--") when is_atom(key) do
     prefix <> String.replace(Atom.to_string(key), "_", "-")
   end
 
   @doc ~S"""
-  Splits a string into `t:argv/0` chunks.
-
-  This function splits the given `string` into a list of strings in a similar
-  way to many shells.
+  Splits a string into argv chunks.
 
   ## Examples
 
@@ -502,10 +371,9 @@ defmodule OptionParser do
 
       iex> OptionParser.split("foo \"bar baz\"")
       ["foo", "bar baz"]
-
   """
-  @spec split(String.t()) :: argv
-  def split(string) when is_binary(string) do
+  @spec split(String.t) :: argv
+  def split(string) do
     do_split(String.trim_leading(string, " "), "", [], nil)
   end
 
@@ -518,7 +386,8 @@ defmodule OptionParser do
     do: do_split(t, buffer, acc, quote)
 
   # If we have a quote and we were inside it, close it
-  defp do_split(<<quote, t::binary>>, buffer, acc, quote), do: do_split(t, buffer, acc, nil)
+  defp do_split(<<quote, t::binary>>, buffer, acc, quote),
+    do: do_split(t, buffer, acc, nil)
 
   # If we have an escaped quote/space, simply remove the escape as long as we are not inside a quote
   defp do_split(<<?\\, h, t::binary>>, buffer, acc, nil) when h in [?\s, ?', ?"],
@@ -534,9 +403,11 @@ defmodule OptionParser do
   end
 
   # Finish the string expecting a nil marker
-  defp do_split(<<>>, "", acc, nil), do: Enum.reverse(acc)
+  defp do_split(<<>>, "", acc, nil),
+    do: Enum.reverse(acc)
 
-  defp do_split(<<>>, buffer, acc, nil), do: Enum.reverse([buffer | acc])
+  defp do_split(<<>>, buffer, acc, nil),
+    do: Enum.reverse([buffer | acc])
 
   # Otherwise raise
   defp do_split(<<>>, _, _acc, marker) do
@@ -545,30 +416,21 @@ defmodule OptionParser do
 
   ## Helpers
 
-  defp build_config(opts) do
-    {switches, strict?} =
-      cond do
-        opts[:switches] && opts[:strict] ->
-          raise ArgumentError, ":switches and :strict cannot be given together"
+  defp compile_config(opts) do
+    aliases = opts[:aliases] || []
 
-        switches = opts[:switches] ->
-          {switches, false}
+    {switches, strict} = cond do
+      opts[:switches] && opts[:strict] ->
+        raise ArgumentError, ":switches and :strict cannot be given together"
+      s = opts[:switches] ->
+        {s, false}
+      s = opts[:strict] ->
+        {s, true}
+      true ->
+        {[], false}
+    end
 
-        strict = opts[:strict] ->
-          {strict, true}
-
-        true ->
-          # TODO: Remove this in Elixir v2.0
-          IO.warn("not passing the :switches or :strict option to OptionParser is deprecated")
-          {[], false}
-      end
-
-    %{
-      aliases: opts[:aliases] || [],
-      allow_nonexistent_atoms?: opts[:allow_nonexistent_atoms] || false,
-      strict?: strict?,
-      switches: switches
-    }
+    {aliases, switches, strict}
   end
 
   defp validate_option(value, kinds) do
@@ -576,32 +438,27 @@ defmodule OptionParser do
       cond do
         :invalid in kinds ->
           {true, value}
-
         :boolean in kinds ->
           case value do
             t when t in [true, "true"] -> {false, true}
             f when f in [false, "false"] -> {false, false}
             _ -> {true, value}
           end
-
         :count in kinds ->
           case value do
-            nil -> {false, 1}
+            1 -> {false, value}
             _ -> {true, value}
           end
-
         :integer in kinds ->
           case Integer.parse(value) do
             {value, ""} -> {false, value}
             _ -> {true, value}
           end
-
         :float in kinds ->
           case Float.parse(value) do
             {value, ""} -> {false, value}
             _ -> {true, value}
           end
-
         true ->
           {false, value}
       end
@@ -613,131 +470,122 @@ defmodule OptionParser do
     end
   end
 
-  defp store_option(dict, option, value, kinds) do
+  defp do_store_option(dict, option, value, kinds) do
     cond do
       :count in kinds ->
-        Keyword.update(dict, option, value, &(&1 + 1))
-
+        Keyword.update(dict, option, value, & &1 + 1)
       :keep in kinds ->
         [{option, value} | dict]
-
       true ->
         [{option, value} | Keyword.delete(dict, option)]
     end
   end
 
-  defp tag_option("no-" <> option = original, config) do
-    %{switches: switches, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
-
+  defp tag_option("-no-" <> option, switches, _aliases) do
     cond do
-      (negated = get_option_key(option, allow_nonexistent_atoms?)) &&
-          :boolean in List.wrap(switches[negated]) ->
+      (negated = get_option(option)) && :boolean in List.wrap(switches[negated]) ->
         {:negated, negated}
-
-      option_key = get_option_key(original, allow_nonexistent_atoms?) ->
-        {:default, option_key}
-
+      option = get_option("no-" <> option) ->
+        {:default, option}
       true ->
         :unknown
     end
   end
 
-  defp tag_option(option, config) do
-    %{allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
-
-    if option_key = get_option_key(option, allow_nonexistent_atoms?) do
-      {:default, option_key}
+  defp tag_option("-" <> option, _switches, _aliases) do
+    if option = get_option(option) do
+      {:default, option}
     else
       :unknown
     end
   end
 
-  defp tag_oneletter_alias(alias, config) when is_binary(alias) do
-    %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
-
-    if option_key = aliases[to_existing_key(alias, allow_nonexistent_atoms?)] do
-      {:default, option_key}
+  defp tag_option(option, _switches, aliases) when is_binary(option) do
+    opt = get_option(option)
+    if alias = aliases[opt] do
+      {:default, alias}
     else
       :unknown
     end
   end
 
-  defp expand_multiletter_alias(letters, value) do
-    {last, expanded} =
-      letters
-      |> Enum.map(&("-" <> &1))
-      |> List.pop_at(-1)
-
-    expanded ++ [last <> if(value, do: "=" <> value, else: "")]
+  defp option_defined?(:unknown, _switches) do
+    false
   end
 
-  defp normalize_tag(:negated, option, value, switches) do
+  defp option_defined?({:negated, option}, switches) do
+    Keyword.has_key?(switches, option)
+  end
+
+  defp option_defined?({:default, option}, switches) do
+    Keyword.has_key?(switches, option)
+  end
+
+  defp normalize_option(:unknown, value, _switches) do
+    {nil, [:invalid], value}
+  end
+
+  defp normalize_option({:negated, option}, value, switches) do
     if value do
-      {[:invalid], value}
+      {option, [:invalid], value}
     else
-      {List.wrap(switches[option]), false}
+      {option, List.wrap(switches[option]), false}
     end
   end
 
-  defp normalize_tag(:default, option, value, switches) do
-    {List.wrap(switches[option]), value}
+  defp normalize_option({:default, option}, value, switches) do
+    {option, List.wrap(switches[option]), value}
   end
 
-  defp normalize_value(nil, kinds, t) do
+  defp normalize_value(nil, kinds, t, strict) do
     cond do
       :boolean in kinds ->
         {true, kinds, t}
-
       :count in kinds ->
-        {nil, kinds, t}
-
+        {1, kinds, t}
       value_in_tail?(t) ->
         [h | t] = t
         {h, kinds, t}
-
+      kinds == [] and strict ->
+        {nil, kinds, t}
       kinds == [] ->
         {true, kinds, t}
-
       true ->
         {nil, [:invalid], t}
     end
   end
 
-  defp normalize_value(value, kinds, t) do
+  defp normalize_value(value, kinds, t, _) do
     {value, kinds, t}
   end
 
-  defp value_in_tail?(["-" | _]), do: true
-  defp value_in_tail?(["- " <> _ | _]), do: true
+  defp value_in_tail?(["-" | _]),        do: true
+  defp value_in_tail?(["- " <> _ | _]),  do: true
   defp value_in_tail?(["-" <> arg | _]), do: negative_number?("-" <> arg)
-  defp value_in_tail?([]), do: false
-  defp value_in_tail?(_), do: true
+  defp value_in_tail?([]),               do: false
+  defp value_in_tail?(_),                do: true
 
   defp split_option(option) do
     case :binary.split(option, "=") do
-      [h] -> {h, nil}
+      [h]    -> {h, nil}
       [h, t] -> {h, t}
     end
   end
 
-  defp to_underscore(option), do: to_underscore(option, <<>>)
-  defp to_underscore("-" <> rest, acc), do: to_underscore(rest, acc <> "_")
-  defp to_underscore(<<c>> <> rest, acc), do: to_underscore(rest, <<acc::binary, c>>)
-  defp to_underscore(<<>>, acc), do: acc
+  defp to_underscore(option),
+    do: to_underscore(option, <<>>)
+  defp to_underscore("_" <> _rest, _acc),
+    do: nil
+  defp to_underscore("-" <> rest, acc),
+    do: to_underscore(rest, acc <> "_")
+  defp to_underscore(<<c>> <> rest, acc),
+    do: to_underscore(rest, <<acc::binary, c>>)
+  defp to_underscore(<<>>, acc),
+    do: acc
 
-  defp get_option_key(option, allow_nonexistent_atoms?) do
-    option
-    |> to_underscore()
-    |> to_existing_key(allow_nonexistent_atoms?)
-  end
-
-  defp to_existing_key(option, true), do: String.to_atom(option)
-
-  defp to_existing_key(option, false) do
-    try do
-      String.to_existing_atom(option)
-    rescue
-      ArgumentError -> nil
+  defp get_option(option) do
+    if str = to_underscore(option) do
+      String.to_atom(str)
     end
   end
 
@@ -745,36 +593,34 @@ defmodule OptionParser do
     match?({_, ""}, Float.parse(arg))
   end
 
-  defp format_errors([_ | _] = errors, opts) do
+  defp format_errors(errors, opts) do
     types = opts[:switches] || opts[:strict]
-    error_count = length(errors)
-    error = if error_count == 1, do: "error", else: "errors"
-
-    "#{error_count} #{error} found!\n" <>
-      Enum.map_join(errors, "\n", &format_error(&1, opts, types))
+    info  = Enum.map(errors, &format_error(&1, opts, types))
+    total = length(errors)
+    error = if total == 1, do: "error", else: "errors"
+    "#{total} #{error} found!#{info}"
   end
 
   defp format_error({option, nil}, opts, types) do
     if type = get_type(option, opts, types) do
-      "#{option} : Missing argument of type #{type}"
+      "\n#{option} : Missing argument of type #{type}"
     else
-      "#{option} : Unknown option"
+      "\n#{option} : Unknown option"
     end
   end
 
   defp format_error({option, value}, opts, types) do
     type = get_type(option, opts, types)
-    "#{option} : Expected type #{type}, got #{inspect(value)}"
+    "\n#{option} : Expected type #{type}, got #{inspect value}"
   end
 
   defp get_type(option, opts, types) do
-    allow_nonexistent_atoms? = opts[:allow_nonexistent_atoms] || false
-    key = option |> String.trim_leading("-") |> get_option_key(allow_nonexistent_atoms?)
+    option_key = option |> String.trim_leading("-") |> get_option()
 
-    if option_key = opts[:aliases][key] do
-      types[option_key]
+    if option_alias = opts[:aliases][option_key] do
+      types[option_alias]
     else
-      types[key]
+      types[option_key]
     end
   end
 end

lib/elixir/lib/path.ex

@@ -12,15 +12,14 @@ defmodule Path do
   that require it (like `wildcard/2` and `expand/1`).
   """
 
+  alias :filename, as: FN
   @type t :: :unicode.chardata()
 
   @doc """
   Converts the given path to an absolute one. Unlike
   `expand/1`, no attempt is made to resolve `..`, `.` or `~`.
 
-  ## Examples
-
-  ### Unix
+  ## Unix examples
 
       Path.absname("foo")
       #=> "/usr/local/foo"
@@ -28,24 +27,22 @@ defmodule Path do
       Path.absname("../x")
       #=> "/usr/local/../x"
 
-  ### Windows
+  ## Windows
 
       Path.absname("foo").
-      #=> "D:/usr/local/foo"
+      "D:/usr/local/foo"
       Path.absname("../x").
-      #=> "D:/usr/local/../x"
+      "D:/usr/local/../x"
 
   """
   @spec absname(t) :: binary
   def absname(path) do
-    absname(path, System.cwd!())
+    absname(path, System.cwd!)
   end
 
   @doc """
-  Builds a path from `relative_to` to `path`.
-
-  If `path` is already an absolute path, `relative_to` is ignored. See also
-  `relative_to/2`.
+  Builds a path from `relative_to` to `path`. If `path` is already
+  an absolute path, `relative_to` is ignored. See also `relative_to/2`.
 
   Unlike `expand/2`, no attempt is made to
   resolve `..`, `.` or `~`.
@@ -62,14 +59,9 @@ defmodule Path do
   @spec absname(t, t) :: binary
   def absname(path, relative_to) do
     path = IO.chardata_to_string(path)
-
     case type(path) do
-      :relative ->
-        absname_join(relative_to, path)
-
-      :absolute ->
-        absname_join([path])
-
+      :relative -> absname_join(relative_to, path)
+      :absolute -> absname_join([path])
       :volumerelative ->
         relative_to = IO.chardata_to_string(relative_to)
         absname_vr(split(path), split(relative_to), relative_to)
@@ -77,7 +69,8 @@ defmodule Path do
   end
 
   # Absolute path on current drive
-  defp absname_vr(["/" | rest], [volume | _], _relative), do: absname_join([volume | rest])
+  defp absname_vr(["/" | rest], [volume | _], _relative),
+    do: absname_join([volume | rest])
 
   # Relative to current directory on current drive.
   defp absname_vr([<<x, ?:>> | rest], [<<x, _::binary>> | _], relative),
@@ -87,56 +80,49 @@ defmodule Path do
   defp absname_vr([<<x, ?:>> | name], _, _relative) do
     cwd =
       case :file.get_cwd([x, ?:]) do
-        {:ok, dir} -> IO.chardata_to_string(dir)
+        {:ok, dir}  -> IO.chardata_to_string(dir)
         {:error, _} -> <<x, ?:, ?/>>
       end
-
     absname(absname_join(name), cwd)
   end
 
   # Joins a list
-  defp absname_join([name1, name2 | rest]), do: absname_join([absname_join(name1, name2) | rest])
-
-  defp absname_join([name]),
-    do: do_absname_join(IO.chardata_to_string(name), <<>>, [], major_os_type())
+  defp absname_join([name1, name2 | rest]), do:
+    absname_join([absname_join(name1, name2) | rest])
+  defp absname_join([name]), do:
+    do_absname_join(IO.chardata_to_string(name), <<>>, [], major_os_type())
 
   # Joins two paths
   defp absname_join(left, right),
     do: do_absname_join(IO.chardata_to_string(left), relative(right), [], major_os_type())
 
-  defp do_absname_join(<<uc_letter, ?:, rest::binary>>, relativename, [], :win32)
-       when uc_letter in ?A..?Z do
-    do_absname_join(rest, relativename, [?:, uc_letter + ?a - ?A], :win32)
-  end
+  defp do_absname_join(<<uc_letter, ?:, rest::binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
+    do_absname_join(rest, relativename, [?:, uc_letter+?a-?A], :win32)
+  defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32), do:
+    do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type), do:
+    do_absname_join(rest, relativename, [?/ | result], os_type)
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type), do:
+    do_absname_join(rest, relativename, [?/ | result], os_type)
+  defp do_absname_join(<<>>, <<>>, result, os_type), do:
+    IO.iodata_to_binary(reverse_maybe_remove_dirsep(result, os_type))
+  defp do_absname_join(<<>>, relativename, [?: | rest], :win32), do:
+    do_absname_join(relativename, <<>>, [?: | rest], :win32)
+  defp do_absname_join(<<>>, relativename, [?/ | result], os_type), do:
+    do_absname_join(relativename, <<>>, [?/ | result], os_type)
+  defp do_absname_join(<<>>, relativename, result, os_type), do:
+    do_absname_join(relativename, <<>>, [?/ | result], os_type)
+  defp do_absname_join(<<char, rest::binary>>, relativename, result, os_type), do:
+    do_absname_join(rest, relativename, [char | result], os_type)
 
-  defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32),
-    do: do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
-
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type),
-    do: do_absname_join(rest, relativename, [?/ | result], os_type)
-
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type),
-    do: do_absname_join(rest, relativename, [?/ | result], os_type)
-
-  defp do_absname_join(<<>>, <<>>, result, os_type),
-    do: IO.iodata_to_binary(reverse_maybe_remove_dir_sep(result, os_type))
-
-  defp do_absname_join(<<>>, relativename, [?: | rest], :win32),
-    do: do_absname_join(relativename, <<>>, [?: | rest], :win32)
-
-  defp do_absname_join(<<>>, relativename, [?/ | result], os_type),
-    do: do_absname_join(relativename, <<>>, [?/ | result], os_type)
-
-  defp do_absname_join(<<>>, relativename, result, os_type),
-    do: do_absname_join(relativename, <<>>, [?/ | result], os_type)
-
-  defp do_absname_join(<<char, rest::binary>>, relativename, result, os_type),
-    do: do_absname_join(rest, relativename, [char | result], os_type)
-
-  defp reverse_maybe_remove_dir_sep([?/, ?:, letter], :win32), do: [letter, ?:, ?/]
-  defp reverse_maybe_remove_dir_sep([?/], _), do: [?/]
-  defp reverse_maybe_remove_dir_sep([?/ | name], _), do: :lists.reverse(name)
-  defp reverse_maybe_remove_dir_sep(name, _), do: :lists.reverse(name)
+  defp reverse_maybe_remove_dirsep([?/, ?:, letter], :win32), do:
+    [letter, ?:, ?/]
+  defp reverse_maybe_remove_dirsep([?/], _), do:
+    [?/]
+  defp reverse_maybe_remove_dirsep([?/ | name], _), do:
+    :lists.reverse(name)
+  defp reverse_maybe_remove_dirsep(name, _), do:
+    :lists.reverse(name)
 
   @doc """
   Converts the path to an absolute one and expands
@@ -150,16 +136,15 @@ defmodule Path do
   """
   @spec expand(t) :: binary
   def expand(path) do
-    expand_dot(absname(expand_home(path), System.cwd!()))
+    expand_dot absname(expand_home(path), System.cwd!)
   end
 
   @doc """
   Expands the path relative to the path given as the second argument
-  expanding any `.` and `..` characters.
+  expanding any `.` and `..` characters. If the path is already an
+  absolute path, `relative_to` is ignored.
 
-  If the path is already an absolute path, `relative_to` is ignored.
-
-  Note that this function treats a `path` with a leading `~` as
+  Note, that this function treats `path` with a leading `~` as
   an absolute one.
 
   The second argument is first expanded to an absolute path.
@@ -178,15 +163,13 @@ defmodule Path do
   """
   @spec expand(t, t) :: binary
   def expand(path, relative_to) do
-    expand_dot(absname(absname(expand_home(path), expand_home(relative_to)), System.cwd!()))
+    expand_dot absname(absname(expand_home(path), expand_home(relative_to)), System.cwd!)
   end
 
   @doc """
   Returns the path type.
 
-  ## Examples
-
-  ### Unix
+  ## Unix examples
 
       Path.type("/")                #=> :absolute
       Path.type("/usr/local/bin")   #=> :absolute
@@ -194,7 +177,7 @@ defmodule Path do
       Path.type("../usr/local/bin") #=> :relative
       Path.type("~/file")           #=> :relative
 
-  ### Windows
+  ## Windows examples
 
       Path.type("D:/usr/local/bin") #=> :absolute
       Path.type("usr/local/bin")    #=> :relative
@@ -203,24 +186,20 @@ defmodule Path do
 
   """
   @spec type(t) :: :absolute | :relative | :volumerelative
-  def type(name)
-      when is_list(name)
-      when is_binary(name) do
-    pathtype(name, major_os_type()) |> elem(0)
+  def type(name) when is_list(name) or is_binary(name) do
+    pathtype(name, major_os_type) |> elem(0)
   end
 
   @doc """
   Forces the path to be a relative path.
 
-  ## Examples
-
-  ### Unix
+  ## Unix examples
 
       Path.relative("/usr/local/bin")   #=> "usr/local/bin"
       Path.relative("usr/local/bin")    #=> "usr/local/bin"
       Path.relative("../usr/local/bin") #=> "../usr/local/bin"
 
-  ### Windows
+  ## Windows examples
 
       Path.relative("D:/usr/local/bin") #=> "usr/local/bin"
       Path.relative("usr/local/bin")    #=> "usr/local/bin"
@@ -236,58 +215,56 @@ defmodule Path do
   defp relative(name, os_type) do
     pathtype(name, os_type)
     |> elem(1)
-    |> IO.chardata_to_string()
+    |> IO.chardata_to_string
   end
 
   defp pathtype(name, os_type) do
     case os_type do
       :win32 -> win32_pathtype(name)
-      _ -> unix_pathtype(name)
+      _      -> unix_pathtype(name)
     end
   end
 
-  defp unix_pathtype(path) when path in ["/", '/'], do: {:absolute, "."}
-  defp unix_pathtype(<<?/, relative::binary>>), do: {:absolute, relative}
-  defp unix_pathtype([?/ | relative]), do: {:absolute, relative}
-  defp unix_pathtype([list | rest]) when is_list(list), do: unix_pathtype(list ++ rest)
-  defp unix_pathtype(relative), do: {:relative, relative}
+  defp unix_pathtype(<<?/, relative::binary>>), do:
+    {:absolute, relative}
+  defp unix_pathtype([?/ | relative]), do:
+    {:absolute, relative}
+  defp unix_pathtype([list | rest]) when is_list(list), do:
+    unix_pathtype(list ++ rest)
+  defp unix_pathtype(relative), do:
+    {:relative, relative}
 
   @slash [?/, ?\\]
 
-  defp win32_pathtype([list | rest]) when is_list(list), do: win32_pathtype(list ++ rest)
+  defp win32_pathtype([list | rest]) when is_list(list), do:
+    win32_pathtype(list++rest)
+  defp win32_pathtype([char, list | rest]) when is_list(list), do:
+    win32_pathtype([char | list++rest])
+  defp win32_pathtype(<<c1, c2, relative::binary>>) when c1 in @slash and c2 in @slash, do:
+    {:absolute, relative}
+  defp win32_pathtype(<<c, relative::binary>>) when c in @slash, do:
+    {:volumerelative, relative}
+  defp win32_pathtype(<<_letter, ?:, c, relative::binary>>) when c in @slash, do:
+    {:absolute, relative}
+  defp win32_pathtype(<<_letter, ?:, relative::binary>>), do:
+    {:volumerelative, relative}
 
-  defp win32_pathtype([char, list | rest]) when is_list(list),
-    do: win32_pathtype([char | list ++ rest])
-
-  defp win32_pathtype(<<c1, c2, relative::binary>>) when c1 in @slash and c2 in @slash,
-    do: {:absolute, relative}
-
-  defp win32_pathtype(<<char, relative::binary>>) when char in @slash,
-    do: {:volumerelative, relative}
-
-  defp win32_pathtype(<<_letter, ?:, char, relative::binary>>) when char in @slash,
-    do: {:absolute, relative}
-
-  defp win32_pathtype(<<_letter, ?:, relative::binary>>), do: {:volumerelative, relative}
-
-  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash,
-    do: {:absolute, relative}
-
-  defp win32_pathtype([char | relative]) when char in @slash, do: {:volumerelative, relative}
-
-  defp win32_pathtype([c1, c2, list | rest]) when is_list(list),
-    do: win32_pathtype([c1, c2 | list ++ rest])
-
-  defp win32_pathtype([_letter, ?:, char | relative]) when char in @slash,
-    do: {:absolute, relative}
-
-  defp win32_pathtype([_letter, ?: | relative]), do: {:volumerelative, relative}
-  defp win32_pathtype(relative), do: {:relative, relative}
+  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash, do:
+    {:absolute, relative}
+  defp win32_pathtype([c | relative]) when c in @slash, do:
+    {:volumerelative, relative}
+  defp win32_pathtype([c1, c2, list | rest]) when is_list(list), do:
+    win32_pathtype([c1, c2 | list++rest])
+  defp win32_pathtype([_letter, ?:, c | relative]) when c in @slash, do:
+    {:absolute, relative}
+  defp win32_pathtype([_letter, ?: | relative]), do:
+    {:volumerelative, relative}
+  defp win32_pathtype(relative), do:
+    {:relative, relative}
 
   @doc """
   Returns the given `path` relative to the given `from` path.
-
-  In other words, this function tries to strip the `from` prefix from `path`.
+  In other words, it tries to strip the `from` prefix from `path`.
 
   This function does not query the file system, so it assumes
   no symlinks between the paths.
@@ -327,14 +304,12 @@ defmodule Path do
 
   @doc """
   Convenience to get the path relative to the current working
-  directory.
-
-  If, for some reason, the current working directory
-  cannot be retrieved, this function returns the given `path`.
+  directory. If, for some reason, the current working directory
+  cannot be retrieved, returns the full path.
   """
   @spec relative_to_cwd(t) :: binary
   def relative_to_cwd(path) do
-    case :file.get_cwd() do
+    case :file.get_cwd do
       {:ok, base} -> relative_to(path, IO.chardata_to_string(base))
       _ -> path
     end
@@ -358,15 +333,13 @@ defmodule Path do
   """
   @spec basename(t) :: binary
   def basename(path) do
-    :filename.basename(IO.chardata_to_string(path))
+    FN.basename(IO.chardata_to_string(path))
   end
 
   @doc """
   Returns the last component of `path` with the `extension`
-  stripped.
-
-  This function should be used to remove a specific
-  extension which may or may not be there.
+  stripped. This function should be used to remove a specific
+  extension which may, or may not, be there.
 
   ## Examples
 
@@ -382,7 +355,7 @@ defmodule Path do
   """
   @spec basename(t, t) :: binary
   def basename(path, extension) do
-    :filename.basename(IO.chardata_to_string(path), IO.chardata_to_string(extension))
+    FN.basename(IO.chardata_to_string(path), IO.chardata_to_string(extension))
   end
 
   @doc """
@@ -396,13 +369,10 @@ defmodule Path do
       iex> Path.dirname("/foo/bar/baz.ex")
       "/foo/bar"
 
-      iex> Path.dirname("/foo/bar/")
-      "/foo/bar"
-
   """
   @spec dirname(t) :: binary
   def dirname(path) do
-    :filename.dirname(IO.chardata_to_string(path))
+    FN.dirname(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -419,7 +389,7 @@ defmodule Path do
   """
   @spec extname(t) :: binary
   def extname(path) do
-    :filename.extension(IO.chardata_to_string(path))
+    FN.extension(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -436,14 +406,12 @@ defmodule Path do
   """
   @spec rootname(t) :: binary
   def rootname(path) do
-    :filename.rootname(IO.chardata_to_string(path))
+    FN.rootname(IO.chardata_to_string(path))
   end
 
   @doc """
-  Returns the `path` with the `extension` stripped.
-
-  This function should be used to remove a specific extension which may
-  or may not be there.
+  Returns the `path` with the `extension` stripped. This function should be used to
+  remove a specific extension which might, or might not, be there.
 
   ## Examples
 
@@ -456,14 +424,14 @@ defmodule Path do
   """
   @spec rootname(t, t) :: binary
   def rootname(path, extension) do
-    :filename.rootname(IO.chardata_to_string(path), IO.chardata_to_string(extension))
+    FN.rootname(IO.chardata_to_string(path), IO.chardata_to_string(extension))
   end
 
   @doc """
-  Joins a list of paths.
+  Joins a list of strings.
 
-  This function should be used to convert a list of paths to a path.
-  Note that any trailing slash is removed when joining.
+  This function should be used to convert a list of strings to a path.
+  Note that any trailing slash is removed on join.
 
   ## Examples
 
@@ -477,53 +445,39 @@ defmodule Path do
       "/foo/bar"
 
   """
-  @spec join(nonempty_list(t)) :: binary
-  def join([name1, name2 | rest]), do: join([join(name1, name2) | rest])
-  def join([name]), do: IO.chardata_to_string(name)
+  @spec join([t]) :: binary
+  def join([name1, name2 | rest]), do:
+    join([join(name1, name2) | rest])
+  def join([name]), do:
+    name
 
   @doc """
   Joins two paths.
 
   The right path will always be expanded to its relative format
-  and any trailing slash will be removed when joining.
+  and any trailing slash is removed on join.
 
   ## Examples
 
       iex> Path.join("foo", "bar")
       "foo/bar"
 
-      iex> Path.join("/foo", "/bar/")
-      "/foo/bar"
-
-  The functions in this module support chardata, so giving a list will
-  treat it as a single entity:
-
-      iex> Path.join("foo", ["bar", "fiz"])
-      "foo/barfiz"
-
-      iex> Path.join(["foo", "bar"], "fiz")
-      "foobar/fiz"
-
   """
   @spec join(t, t) :: binary
   def join(left, right) do
-    left = IO.chardata_to_string(left)
+    left    = IO.chardata_to_string(left)
     os_type = major_os_type()
-    do_join(left, right, os_type) |> remove_dir_sep(os_type)
+    do_join(left, right, os_type) |> remove_dirsep(os_type)
   end
 
-  defp do_join("", right, os_type), do: relative(right, os_type)
-  defp do_join("/", right, os_type), do: "/" <> relative(right, os_type)
+  defp do_join("", right, os_type),   do: relative(right, os_type)
+  defp do_join("/", right, os_type),  do: "/" <> relative(right, os_type)
+  defp do_join(left, right, os_type), do: remove_dirsep(left, os_type) <> "/" <> relative(right, os_type)
 
-  defp do_join(left, right, os_type),
-    do: remove_dir_sep(left, os_type) <> "/" <> relative(right, os_type)
-
-  defp remove_dir_sep("", _os_type), do: ""
-  defp remove_dir_sep("/", _os_type), do: "/"
-
-  defp remove_dir_sep(bin, os_type) do
+  defp remove_dirsep("", _os_type), do: ""
+  defp remove_dirsep("/", _os_type), do: "/"
+  defp remove_dirsep(bin, os_type) do
     last = :binary.last(bin)
-
     if last == ?/ or (last == ?\\ and os_type == :win32) do
       binary_part(bin, 0, byte_size(bin) - 1)
     else
@@ -558,7 +512,7 @@ defmodule Path do
   def split(""), do: []
 
   def split(path) do
-    :filename.split(IO.chardata_to_string(path))
+    FN.split(IO.chardata_to_string(path))
   end
 
   defmodule Wildcard do
@@ -568,11 +522,15 @@ defmodule Path do
       call({:read_link_info, file})
     end
 
+    # For compatibility with buggy Erlang 17.1.
+    def read_file_info(file) do
+      call({:read_link_info, file})
+    end
+
     def list_dir(dir) do
-      case call({:list_dir, dir}) do
+      case call({:list_dir, dir})  do
         {:ok, files} ->
           {:ok, for(file <- files, hd(file) != ?., do: file)}
-
         other ->
           other
       end
@@ -589,47 +547,41 @@ defmodule Path do
   end
 
   @doc """
-  Traverses paths according to the given `glob` expression and returns a
+  Traverses paths according to the given `glob` expression, and returns a
   list of matches.
 
-  The wildcard looks like an ordinary path, except that the following
-  "wildcard characters" are interpreted in a special way:
+  The wildcard looks like an ordinary path, except that certain
+  "wildcard characters" are interpreted in a special way. The
+  following characters are special:
 
-    * `?` - matches one character.
+    * `?` - matches one character
 
     * `*` - matches any number of characters up to the end of the filename, the
-      next dot, or the next slash.
+      next dot, or the next slash
 
     * `**` - two adjacent `*`'s used as a single pattern will match all
-      files and zero or more directories and subdirectories.
+      files and zero or more directories and subdirectories
 
     * `[char1,char2,...]` - matches any of the characters listed; two
       characters separated by a hyphen will match a range of characters.
       Do not add spaces before and after the comma as it would then match
       paths containing the space character itself.
 
-    * `{item1,item2,...}` - matches one of the alternatives.
+    * `{item1,item2,...}` - matches one of the alternatives
       Do not add spaces before and after the comma as it would then match
       paths containing the space character itself.
 
   Other characters represent themselves. Only paths that have
   exactly the same character in the same position will match. Note
-  that matching is case-sensitive: `"a"` will not match `"A"`.
+  that matching is case-sensitive; i.e. "a" will not match "A".
 
   By default, the patterns `*` and `?` do not match files starting
-  with a dot `.`. See the `:match_dot` option in the "Options" section
-  below.
-
-  ## Options
-
-    * `:match_dot` - (boolean) if `false`, the special wildcard characters `*` and `?`
-      will not match files starting with a dot (`.`). If `true`, files starting with
-      a `.` will not be treated specially. Defaults to `false`.
+  with a dot `.` unless `match_dot: true` is given in `opts`.
 
   ## Examples
 
   Imagine you have a directory called `projects` with three Elixir projects
-  inside of it: `elixir`, `ex_doc`, and `plug`. You can find all `.beam` files
+  inside of it: `elixir`, `ex_doc` and `dynamo`. You can find all `.beam` files
   inside the `ebin` directory of each project as follows:
 
       Path.wildcard("projects/*/ebin/**/*.beam")
@@ -639,25 +591,21 @@ defmodule Path do
       Path.wildcard("projects/*/ebin/**/*.{beam,app}")
 
   """
-  @spec wildcard(t, keyword) :: [binary]
+  @spec wildcard(t, Keyword.t) :: [binary]
   def wildcard(glob, opts \\ []) do
     mod = if Keyword.get(opts, :match_dot), do: :file, else: Path.Wildcard
-
     glob
-    |> chardata_to_list!()
+    |> chardata_to_list()
     |> :filelib.wildcard(mod)
     |> Enum.map(&IO.chardata_to_string/1)
   end
 
-  defp chardata_to_list!(chardata) do
+  # expand_dot the given path by expanding "..", "." and "~".
+
+  defp chardata_to_list(chardata) do
     case :unicode.characters_to_list(chardata) do
       result when is_list(result) ->
-        if 0 in result do
-          raise ArgumentError,
-                "cannot execute Path.wildcard/2 for path with null byte, got: #{inspect(chardata)}"
-        else
-          result
-        end
+        result
 
       {:error, encoded, rest} ->
         raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
@@ -670,42 +618,46 @@ defmodule Path do
   defp expand_home(type) do
     case IO.chardata_to_string(type) do
       "~" <> rest -> resolve_home(rest)
-      rest -> rest
+      rest        -> rest
     end
   end
 
-  defp resolve_home(""), do: System.user_home!()
+  defp resolve_home(""), do: System.user_home!
 
   defp resolve_home(rest) do
-    case {rest, major_os_type()} do
+    case {rest, major_os_type} do
       {"\\" <> _, :win32} ->
-        System.user_home!() <> rest
-
+        System.user_home! <> rest
       {"/" <> _, _} ->
-        System.user_home!() <> rest
-
-      _ ->
-        rest
+        System.user_home! <> rest
+      _ -> rest
     end
   end
 
-  # expand_dot the given path by expanding "..", "." and "~".
-  defp expand_dot(<<"/", rest::binary>>), do: "/" <> do_expand_dot(rest)
-
+  defp expand_dot(<<"/", rest::binary>>),
+    do: "/" <> do_expand_dot(rest)
   defp expand_dot(<<letter, ":/", rest::binary>>) when letter in ?a..?z,
     do: <<letter, ":/">> <> do_expand_dot(rest)
+  defp expand_dot(path),
+    do: do_expand_dot(path)
 
-  defp expand_dot(path), do: do_expand_dot(path)
+  defp do_expand_dot(path),
+    do: do_expand_dot(:binary.split(path, "/", [:global]), [])
 
-  defp do_expand_dot(path), do: do_expand_dot(:binary.split(path, "/", [:global]), [])
-  defp do_expand_dot([".." | t], [_, _ | acc]), do: do_expand_dot(t, acc)
-  defp do_expand_dot([".." | t], []), do: do_expand_dot(t, [])
-  defp do_expand_dot(["." | t], acc), do: do_expand_dot(t, acc)
-  defp do_expand_dot([h | t], acc), do: do_expand_dot(t, ["/", h | acc])
-  defp do_expand_dot([], []), do: ""
-  defp do_expand_dot([], ["/" | acc]), do: IO.iodata_to_binary(:lists.reverse(acc))
+  defp do_expand_dot([".." | t], [_, _ | acc]),
+    do: do_expand_dot(t, acc)
+  defp do_expand_dot([".." | t], []),
+    do: do_expand_dot(t, [])
+  defp do_expand_dot(["." | t], acc),
+    do: do_expand_dot(t, acc)
+  defp do_expand_dot([h | t], acc),
+    do: do_expand_dot(t, ["/", h | acc])
+  defp do_expand_dot([], []),
+    do: ""
+  defp do_expand_dot([], ["/" | acc]),
+    do: IO.iodata_to_binary(:lists.reverse(acc))
 
   defp major_os_type do
-    :os.type() |> elem(0)
+    :os.type |> elem(0)
   end
 end

lib/elixir/lib/port.ex

@@ -1,190 +1,44 @@
 defmodule Port do
-  @moduledoc ~S"""
-  Functions for interacting with the external world through ports.
-
-  Ports provide a mechanism to start operating system processes external
-  to the Erlang VM and communicate with them via message passing.
-
-  ## Example
-
-      iex> port = Port.open({:spawn, "cat"}, [:binary])
-      iex> send(port, {self(), {:command, "hello"}})
-      iex> send(port, {self(), {:command, "world"}})
-      iex> flush()
-      {#Port<0.1444>, {:data, "hello"}}
-      {#Port<0.1444>, {:data, "world"}}
-      iex> send(port, {self(), :close})
-      :ok
-      iex> flush()
-      {#Port<0.1464>, :closed}
-      :ok
-
-  In the example above, we have created a new port that executes the
-  program `cat`. `cat` is a program available on UNIX systems that
-  receives data from multiple inputs and concatenates them in the output.
-
-  After the port was created, we sent it two commands in the form of
-  messages using `Kernel.send/2`. The first command has the binary payload
-  of "hello" and the second has "world".
-
-  After sending those two messages, we invoked the IEx helper `flush()`,
-  which printed all messages received from the port, in this case we got
-  "hello" and "world" back. Notice the messages are in binary because we
-  passed the `:binary` option when opening the port in `Port.open/2`. Without
-  such option, it would have yielded a list of bytes.
-
-  Once everything was done, we closed the port.
-
-  Elixir provides many conveniences for working with ports and some drawbacks.
-  We will explore those below.
-
-  ## Message and function APIs
-
-  There are two APIs for working with ports. It can be either asynchronous via
-  message passing, as in the example above, or by calling the functions on this
-  module.
-
-  The messages supported by ports and their counterpart function APIs are
-  listed below:
-
-    * `{pid, {:command, binary}}` - sends the given data to the port.
-      See `command/3`.
-
-    * `{pid, :close}` - closes the port. Unless the port is already closed,
-      the port will reply with `{port, :closed}` message once it has flushed
-      its buffers and effectively closed. See `close/1`.
-
-    * `{pid, {:connect, new_pid}}` - sets the `new_pid` as the new owner of
-      the port. Once a port is opened, the port is linked and connected to the
-      caller process and communication to the port only happens through the
-      connected process. This message makes `new_pid` the new connected processes.
-      Unless the port is dead, the port will reply to the old owner with
-      `{port, :connected}`. See `connect/2`.
-
-  On its turn, the port will send the connected process the following messages:
-
-    * `{port, {:data, data}}` - data sent by the port
-    * `{port, :closed}` - reply to the `{pid, :close}` message
-    * `{port, :connected}` - reply to the `{pid, {:connect, new_pid}}` message
-    * `{:EXIT, port, reason}` - exit signals in case the port crashes. If reason
-      is not `:normal`, this message will only be received if the owner process
-      is trapping exits
-
-  ## Open mechanisms
-
-  The port can be opened through four main mechanisms.
-
-  As a short summary, prefer to using the `:spawn` and `:spawn_executable`
-  options mentioned below. The other two options, `:spawn_driver` and `:fd`
-  are for advanced usage within the VM. Also consider using `System.cmd/3`
-  if all you want is to execute a program and retrieve its return value.
-
-  ### spawn
-
-  The `:spawn` tuple receives a binary that is going to be executed as a
-  full invocation. For example, we can use it to invoke "echo hello" directly:
-
-      iex> port = Port.open({:spawn, "echo hello"}, [:binary])
-      iex> flush()
-      {#Port<0.1444>, {:data, "hello\n"}}
-
-  `:spawn` will retrieve the program name from the argument and traverse your
-  OS `$PATH` environment variable looking for a matching program.
-
-  Although the above is handy, it means it is impossible to invoke an executable
-  that has whitespaces on its name or in any of its arguments. For those reasons,
-  most times it is preferable to execute `:spawn_executable`.
-
-  ### spawn_executable
-
-  Spawn executable is a more restricted and explicit version of spawn. It expects
-  full file paths to the executable you want to execute. If they are in your `$PATH`,
-  they can be retrieved by calling `System.find_executable/1`:
-
-      iex> path = System.find_executable("echo")
-      iex> port = Port.open({:spawn_executable, path}, [:binary, args: ["hello world"]])
-      iex> flush()
-      {#Port<0.1380>, {:data, "hello world\n"}}
-
-  When using `:spawn_executable`, the list of arguments can be passed via
-  the `:args` option as done above. For the full list of options, see the
-  documentation for the Erlang function `:erlang.open_port/2`.
-
-  ### fd
-
-  The `:fd` name option allows developers to access `in` and `out` file
-  descriptors used by the Erlang VM. You would use those only if you are
-  reimplementing core part of the Runtime System, such as the `:user` and
-  `:shell` processes.
-
-  ## Zombie OS processes
-
-  A port can be closed via the `close/1` function or by sending a `{pid, :close}`
-  message. However, if the VM crashes, a long-running program started by the port
-  will have its stdin and stdout channels closed but **it won't be automatically
-  terminated**.
-
-  While most UNIX command line tools will exit once its communication channels
-  are closed, not all command line applications will do so. While we encourage
-  graceful termination by detecting if stdin/stdout has been closed, we do not
-  always have control over how 3rd party software terminates. In those cases,
-  you can wrap the application in a script that checks for stdin. Here is such
-  script in bash:
-
-      #!/bin/sh
-      "$@" &
-      pid=$!
-      while read line ; do
-        :
-      done
-      kill -KILL $pid
-
-  Now instead of:
-
-      Port.open({:spawn_executable, "/path/to/program"},
-                [args: ["a", "b", "c"]])
-
-  You may invoke:
-
-      Port.open({:spawn_executable, "/path/to/wrapper"},
-                [args: ["/path/to/program", "a", "b", "c"]])
-
+  @moduledoc """
+  Functions related to Erlang ports.
   """
 
-  @type name ::
-          {:spawn, charlist | binary}
-          | {:spawn_driver, charlist | binary}
-          | {:spawn_executable, charlist | atom}
-          | {:fd, non_neg_integer, non_neg_integer}
+  @type name :: {:spawn, charlist | binary} |
+                {:spawn_driver, charlist | binary} |
+                {:spawn_executable, charlist | atom} |
+                {:fd, non_neg_integer, non_neg_integer}
 
   @doc """
-  Opens a port given a tuple `name` and a list of `options`.
+  Opens an Erlang port given a tuple `name` and a list of `settings`.
 
-  The module documentation above contains documentation and examples
-  for the supported `name` values, summarized below:
+  ## Name
 
-    * `{:spawn, command}` - runs an external program. `command` must contain
-      the program name and optionally a list of arguments separated by space.
-      If passing programs or arguments with space in their name, use the next option.
-    * `{:spawn_executable, filename}` - runs the executable given by the absolute
-      file name `filename`. Arguments can be passed via the `:args` option.
-    * `{:spawn_driver, command}` - spawns so-called port drivers.
-    * `{:fd, fd_in, fd_out}` - accesses file descriptors, `fd_in` and `fd_out`
-      opened by the VM.
+  The supported values for `name` are:
 
-  For more information and the list of options, see `:erlang.open_port/2`.
+    * `{:spawn, command}` - to run an external program. The first space separated
+      word of `command` will be considered as the name of the program to run, so
+      use `{:spawn_executable, command}` to run a program having spaces in its name.
+    * `{:spawn_driver, command}` - similar to `{:spawn, command}`, but to run a
+      loaded driver.
+    * `{:spawn_executable, filename}` - similar to `{:spawn, filename}`, but to run
+      an external executable. With this option, `filename` in its whole is considered
+      the name of the program to execute.
+    * `{:fd, fd_in, fd_out}` - to access file descriptors used by Erlang, `fd_in`
+      being used for standard input, `fd_out` for standard output.
+
+  For more information, see [`:erlang.open_port/2`](http://www.erlang.org/doc/man/erlang.html#open_port-2).
 
   Inlined by the compiler.
   """
   @spec open(name, list) :: port
-  def open(name, options) do
-    :erlang.open_port(name, options)
+  def open(name, settings) do
+    :erlang.open_port(name, settings)
   end
 
   @doc """
   Closes the `port`.
 
-  For more information, see `:erlang.port_close/1`.
+  For more information, see [`:erlang.port_close/1`](http://www.erlang.org/doc/man/erlang.html#port_close-1).
 
   Inlined by the compiler.
   """
@@ -196,7 +50,7 @@ defmodule Port do
   @doc """
   Sends `data` to the port driver `port`.
 
-  For more information, see `:erlang.port_command/2`.
+  For more information, see [`:erlang.port_command/2`](http://www.erlang.org/doc/man/erlang.html#port_command-2).
 
   Inlined by the compiler.
   """
@@ -208,7 +62,7 @@ defmodule Port do
   @doc """
   Associates the `port` identifier with a `pid`.
 
-  For more information, see `:erlang.port_connect/2`.
+  For more information, see [`:erlang.port_connect/2`](http://www.erlang.org/doc/man/erlang.html#port_connect-2).
 
   Inlined by the compiler.
   """
@@ -218,85 +72,76 @@ defmodule Port do
   end
 
   @doc """
-  Returns information about the `port` or `nil` if the port is closed.
+  Sends a synchronous control command to the `port` and returns its reply as a binary.
 
-  For more information, see `:erlang.port_info/1`.
+  Not all port drivers support this feature.
+
+  For more information, see [`:erlang.port_control/3`](http://www.erlang.org/doc/man/erlang.html#port_control-3).
+
+  Inlined by the compiler.
   """
-  def info(port) do
-    nillify(:erlang.port_info(port))
+  @spec control(port, integer, iodata) :: iodata | binary
+  def control(port, operation, data) do
+    :erlang.port_control(port, operation, data)
   end
 
   @doc """
-  Returns information about the `port` or `nil` if the port is closed.
+  Makes a synchronous call to the `port` and returns its reply as a term.
 
-  For more information, see `:erlang.port_info/2`.
+  Not all port drivers support this control feature.
+
+  For more information, see [`:erlang.port_call/3`](http://www.erlang.org/doc/man/erlang.html#port_call-3).
+
+  Inlined by the compiler.
+  """
+  @spec call(port, integer, term) :: term
+  def call(port, operation, data) do
+    :erlang.port_call(port, operation, data)
+  end
+
+  @doc """
+  Returns information about the `port`
+  or `nil` if the port is closed.
+
+  For more information, see [`:erlang.port_info/1`](http://www.erlang.org/doc/man/erlang.html#port_info-1).
+  """
+  def info(port) do
+    nillify :erlang.port_info(port)
+  end
+
+  @doc """
+  Returns information about the `port`
+  or `nil` if the port is closed.
+
+  For more information, see [`:erlang.port_info/2`](http://www.erlang.org/doc/man/erlang.html#port_info-2).
   """
   @spec info(port, atom) :: {atom, term} | nil
   def info(port, spec)
 
   def info(port, :registered_name) do
     case :erlang.port_info(port, :registered_name) do
-      :undefined -> nil
       [] -> {:registered_name, []}
-      other -> other
+      other -> nillify(other)
     end
   end
 
   def info(port, item) do
-    nillify(:erlang.port_info(port, item))
+    nillify :erlang.port_info(port, item)
   end
 
   @doc """
-  Starts monitoring the given `port` from the calling process.
+  Returns a list of the ports for the current node.
 
-  Once the monitored port process dies, a message is delivered to the
-  monitoring process in the shape of:
-
-      {:DOWN, ref, :port, object, reason}
-
-  where:
-
-    * `ref` is a monitor reference returned by this function;
-    * `object` is either the `port` being monitored (when monitoring by port id)
-    or `{name, node}` (when monitoring by a port name);
-    * `reason` is the exit reason.
-
-  See `:erlang.monitor/2` for more info.
-
-  Inlined by the compiler.
-  """
-  @doc since: "1.6.0"
-  @spec monitor(port | {name :: atom, node :: atom} | name :: atom) :: reference
-  def monitor(port) do
-    :erlang.monitor(:port, port)
-  end
-
-  @doc """
-  Demonitors the monitor identified by the given `reference`.
-
-  If `monitor_ref` is a reference which the calling process
-  obtained by calling `monitor/1`, that monitoring is turned off.
-  If the monitoring is already turned off, nothing happens.
-
-  See `:erlang.demonitor/2` for more info.
-
-  Inlined by the compiler.
-  """
-  @doc since: "1.6.0"
-  @spec demonitor(reference, options :: [:flush | :info]) :: boolean
-  defdelegate demonitor(monitor_ref, options \\ []), to: :erlang
-
-  @doc """
-  Returns a list of all ports in the current node.
+  For more information, see [`:erlang.ports/0`](http://www.erlang.org/doc/man/erlang.html#ports-0).
 
   Inlined by the compiler.
   """
   @spec list :: [port]
   def list do
-    :erlang.ports()
+    :erlang.ports
   end
 
   @compile {:inline, nillify: 1}
   defp nillify(:undefined), do: nil
-  defp nillify(other), do: other
+  defp nillify(other),      do: other
 end

lib/elixir/lib/process.ex

@@ -4,7 +4,7 @@ defmodule Process do
 
   Besides the functions available in this module, the `Kernel` module
   exposes and auto-imports some basic functionality related to processes
-  available through the following functions:
+  available through the functions:
 
     * `Kernel.spawn/1` and `Kernel.spawn/3`
     * `Kernel.spawn_link/1` and `Kernel.spawn_link/3`
@@ -12,53 +12,42 @@ defmodule Process do
     * `Kernel.self/0`
     * `Kernel.send/2`
 
-  While this module provides low-level conveniences to work with processes,
-  developers typically use abstractions such as `Agent`, `GenServer`,
-  `Registry`, `Supervisor` and `Task`  for building their systems and
-  resort to this module for gathering information, trapping exits, links
-  and monitoring.
   """
 
   @doc """
-  Tells whether the given process is alive on the local node.
+  Returns `true` if the process exists and is alive (i.e. it is not exiting
+  and has not exited yet). Otherwise, returns `false`.
 
-  If the process identified by `pid` is alive (that is, it's not exiting and has
-  not exited yet) than this function returns `true`. Otherwise, it returns
-  `false`.
-
-  `pid` must refer to a process running on the local node or `ArgumentError` is raised.
+  `pid` must refer to a process at the local node.
 
   Inlined by the compiler.
   """
-
-  @typedoc """
-  A process destination.
-
-  A remote or local PID, a local port, a locally registered name, or a tuple in
-  the form of `{registered_name, node}` for a registered name at another node.
-  """
-  @type dest :: pid | port | registered_name :: atom | {registered_name :: atom, node}
-
   @spec alive?(pid) :: boolean
-  defdelegate alive?(pid), to: :erlang, as: :is_process_alive
+  def alive?(pid) do
+    :erlang.is_process_alive(pid)
+  end
 
   @doc """
   Returns all key-value pairs in the process dictionary.
 
   Inlined by the compiler.
   """
-  @spec get() :: [{term, term}]
-  defdelegate get(), to: :erlang
+  @spec get :: [{term, term}]
+  def get do
+    :erlang.get()
+  end
 
   @doc """
-  Returns the value for the given `key` in the process dictionary,
-  or `default` if `key` is not set.
+  Returns the value for the given `key` or `default` if `key` is not set.
   """
+  @spec get(term) :: term
   @spec get(term, default :: term) :: term
   def get(key, default \\ nil) do
     case :erlang.get(key) do
-      :undefined -> default
-      value -> value
+      :undefined ->
+        default
+      value ->
+        value
     end
   end
 
@@ -68,58 +57,41 @@ defmodule Process do
   Inlined by the compiler.
   """
   @spec get_keys() :: [term]
-  defdelegate get_keys(), to: :erlang
+  def get_keys() do
+    :erlang.get_keys()
+  end
 
   @doc """
-  Returns all keys in the process dictionary that have the given `value`.
+  Returns all keys that have the given `value`.
 
   Inlined by the compiler.
   """
   @spec get_keys(term) :: [term]
-  defdelegate get_keys(value), to: :erlang
+  def get_keys(value) do
+    :erlang.get_keys(value)
+  end
 
   @doc """
   Stores the given `key`-`value` pair in the process dictionary.
 
-  The return value of this function is the value that was previously stored
-  under `key`, or `nil` in case no value was stored under `key`.
-
-  ## Examples
-
-      # Assuming :locale was not set
-      Process.put(:locale, "en")
-      #=> nil
-      Process.put(:locale, "fr")
-      #=> "en"
-
+  The return value is the value that was previously stored under the key `key`
+  (or `nil` in case no value was stored under `key`).
   """
   @spec put(term, term) :: term | nil
   def put(key, value) do
-    nillify(:erlang.put(key, value))
+    nillify :erlang.put(key, value)
   end
 
   @doc """
   Deletes the given `key` from the process dictionary.
-
-  Returns the value that was under `key` in the process dictionary,
-  or `nil` if `key` was not stored in the process dictionary.
-
-  ## Examples
-
-      Process.put(:comments, ["comment", "other comment"])
-      Process.delete(:comments)
-      #=> ["comment", "other comment"]
-      Process.delete(:comments)
-      #=> nil
-
   """
   @spec delete(term) :: term | nil
   def delete(key) do
-    nillify(:erlang.erase(key))
+    nillify :erlang.erase(key)
   end
 
   @doc """
-  Sends an exit signal with the given `reason` to `pid`.
+  Sends an exit signal with the given `reason` to the `pid`.
 
   The following behaviour applies if `reason` is any term except `:normal`
   or `:kill`:
@@ -131,42 +103,42 @@ defmodule Process do
        message `{:EXIT, from, reason}` and delivered to the message queue
        of `pid`.
 
-  If `reason` is the atom `:normal`, `pid` will not exit (unless `pid` is
-  the calling process, in which case it will exit with the reason `:normal`).
-  If it is trapping exits, the exit signal is transformed into a message
-  `{:EXIT, from, :normal}` and delivered to its message queue.
+    3. If `reason` is the atom `:normal`, `pid` will not exit (unless it
+       is the calling process's pid, in which case it will exit with the
+       reason `:normal`). If it is trapping exits, the exit signal is
+       transformed into a message `{:EXIT, from, :normal}` and delivered
+       to its message queue.
 
-  If `reason` is the atom `:kill`, that is if `Process.exit(pid, :kill)` is called,
-  an untrappable exit signal is sent to `pid` which will unconditionally exit
-  with reason `:killed`.
+    4. If `reason` is the atom `:kill`, that is if `exit(pid, :kill)` is
+       called, an untrappable exit signal is sent to `pid` which will
+       unconditionally exit with exit reason `:killed`.
 
   Inlined by the compiler.
 
   ## Examples
 
       Process.exit(pid, :kill)
-      #=> true
 
   """
   @spec exit(pid, term) :: true
-  defdelegate exit(pid, reason), to: :erlang
+  def exit(pid, reason) do
+    :erlang.exit(pid, reason)
+  end
 
   @doc """
-  Sleeps the current process for the given `timeout`.
+  Sleeps the current process by `timeout`.
 
   `timeout` is either the number of milliseconds to sleep as an
   integer or the atom `:infinity`. When `:infinity` is given,
-  the current process will sleep forever, and not
-  consume or reply to messages.
+  the current process will suspend forever.
 
   **Use this function with extreme care**. For almost all situations
   where you would use `sleep/1` in Elixir, there is likely a
-  more correct, faster and precise way of achieving the same with
+  more correct, faster and precise way of achieving it with
   message passing.
 
-  For example, if you are waiting for a process to perform some
-  action, it is better to communicate the progress of such action
-  with messages.
+  For example, if you are waiting a process to perform some
+  action, it is better to communicate.
 
   In other words, **do not**:
 
@@ -193,11 +165,11 @@ defmodule Process do
         30_000 -> :timeout # Optional timeout
       end
 
-  For cases like the one above, `Task.async/1` and `Task.await/2` are
-  preferred.
+  Or even use `Task.async/1` and `Task.await/2` in the example
+  above.
 
   Similarly, if you are waiting for a process to terminate,
-  monitor that process instead of sleeping. **Do not**:
+  use monitor instead of sleep. **Do not**:
 
       Task.start_link fn ->
         ...
@@ -221,7 +193,6 @@ defmodule Process do
       end
 
   """
-  @spec sleep(timeout) :: :ok
   def sleep(timeout)
       when is_integer(timeout) and timeout >= 0
       when timeout == :infinity do
@@ -229,110 +200,71 @@ defmodule Process do
   end
 
   @doc """
-  Sends a message to the given `dest`.
+  Sends a message to the given process.
 
-  `dest` may be a remote or local PID, a local port, a locally
-  registered name, or a tuple in the form of `{registered_name, node}` for a
-  registered name at another node.
+  If the option `:noconnect` is used and sending the message would require an
+  auto-connection to another node the message is not sent and `:noconnect` is
+  returned.
 
-  Inlined by the compiler.
-
-  ## Options
-
-    * `:noconnect` - when used, if sending the message would require an
-      auto-connection to another node the message is not sent and `:noconnect` is
-      returned.
-
-    * `:nosuspend` - when used, if sending the message would cause the sender to
-      be suspended the message is not sent and `:nosuspend` is returned.
+  If the option `:nosuspend` is used and sending the message would cause the
+  sender to be suspended the message is not sent and `:nosuspend` is returned.
 
   Otherwise the message is sent and `:ok` is returned.
 
   ## Examples
 
-      iex> Process.send({:name, :node_that_does_not_exist}, :hi, [:noconnect])
+      iex> Process.send({:name, :node_does_not_exist}, :hi, [:noconnect])
       :noconnect
 
   """
-  @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
-        when dest: dest(),
-             msg: any,
-             option: :noconnect | :nosuspend
-  defdelegate send(dest, msg, options), to: :erlang
+  @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend when
+        dest: pid | port | atom | {atom, node},
+        msg: any,
+        option: :noconnect | :nosuspend
+  def send(dest, msg, options) do
+    :erlang.send(dest, msg, options)
+  end
 
   @doc """
   Sends `msg` to `dest` after `time` milliseconds.
 
-  If `dest` is a PID, it must be the PID of a local process, dead or alive.
+  If `dest` is a pid, it must be the pid of a local process, dead or alive.
   If `dest` is an atom, it must be the name of a registered process
-  which is looked up at the time of delivery. No error is produced if the name does
+  which is looked up at the time of delivery. No error is given if the name does
   not refer to a process.
 
-  This function returns a timer reference, which can be read with `read_timer/1`
-  or canceled with `cancel_timer/1`.
+  This function returns a timer reference, which can be read or canceled with
+  `read_timer/1` and `cancel_timer/1`.
 
-  The timer will be automatically canceled if the given `dest` is a PID
-  which is not alive or when the given PID exits. Note that timers will not be
+  Finally, the timer will be automatically canceled if the given `dest` is a pid
+  which is not alive or when the given pid exits. Note that timers will not be
   automatically canceled when `dest` is an atom (as the atom resolution is done
   on delivery).
-
-  Inlined by the compiler.
-
-  ## Options
-
-    * `:abs` - (boolean) when `false`, `time` is treated as relative to the
-    current monotonic time. When `true`, `time` is the absolute value of the
-    Erlang monotonic time at which `msg` should be delivered to `dest`.
-    To read more about Erlang monotonic time and other time-related concepts,
-    look at the documentation for the `System` module. Defaults to `false`.
-
-  ## Examples
-
-      timer_ref = Process.send_after(pid, :hi, 1000)
-
   """
-  @spec send_after(pid | atom, term, non_neg_integer, [option]) :: reference
-        when option: {:abs, boolean}
-  def send_after(dest, msg, time, opts \\ []) do
-    :erlang.send_after(time, dest, msg, opts)
+  @spec send_after(pid | atom, term, non_neg_integer) :: reference
+  def send_after(dest, msg, time) do
+    :erlang.send_after(time, dest, msg)
   end
 
   @doc """
-  Cancels a timer returned by `send_after/3`.
+  Cancels a timer created by `send_after/3`.
 
   When the result is an integer, it represents the time in milliseconds
   left until the timer would have expired.
 
-  When the result is `false`, a timer corresponding to `timer_ref` could not be
-  found. This can happen either because the timer expired, because it has
-  already been canceled, or because `timer_ref` never corresponded to a timer.
+  When the result is `false`, a timer corresponding to `timer_ref` could
+  not be found. This can be either because the timer expired, already has
+  been canceled, or because `timer_ref` never corresponded to a timer.
 
-  Even if the timer had expired and the message was sent, this function does not
-  tell you if the timeout message has arrived at its destination yet.
+  If the timer has expired, the timeout message has been sent, but it does
+  not tell you whether or not it has arrived at its destination yet.
 
   Inlined by the compiler.
-
-  ## Options
-
-    * `:async` - (boolean) when `false`, the request for cancellation is
-      synchronous. When `true`, the request for cancellation is asynchronous,
-      meaning that the request to cancel the timer is issued and `:ok` is
-      returned right away. Defaults to `false`.
-
-    * `:info` - (boolean) whether to return information about the timer being
-      cancelled. When the `:async` option is `false` and `:info` is `true`, then
-      either an integer or `false` (like described above) is returned. If
-      `:async` is `false` and `:info` is `false`, `:ok` is returned. If `:async`
-      is `true` and `:info` is `true`, a message in the form `{:cancel_timer,
-      timer_ref, result}` (where `result` is an integer or `false` like
-      described above) is sent to the caller of this function when the
-      cancellation has been performed. If `:async` is `true` and `:info` is
-      `false`, no message is sent. Defaults to `true`.
-
   """
-  @spec cancel_timer(reference, options) :: non_neg_integer | false | :ok
-        when options: [async: boolean, info: boolean]
-  defdelegate cancel_timer(timer_ref, options \\ []), to: :erlang
+  @spec cancel_timer(reference) :: non_neg_integer | false
+  def cancel_timer(timer_ref) do
+    :erlang.cancel_timer(timer_ref)
+  end
 
   @doc """
   Reads a timer created by `send_after/3`.
@@ -340,25 +272,24 @@ defmodule Process do
   When the result is an integer, it represents the time in milliseconds
   left until the timer will expire.
 
-  When the result is `false`, a timer corresponding to `timer_ref` could not be
-  found. This can be either because the timer expired, because it has already
+  When the result is `false`, a timer corresponding to `timer_ref` could
+  not be found. This can be either because the timer expired, already has
   been canceled, or because `timer_ref` never corresponded to a timer.
 
-  Even if the timer had expired and the message was sent, this function does not
-  tell you if the timeout message has arrived at its destination yet.
+  If the timer has expired, the timeout message has been sent, but it does
+  not tell you whether or not it has arrived at its destination yet.
 
   Inlined by the compiler.
   """
   @spec read_timer(reference) :: non_neg_integer | false
-  defdelegate read_timer(timer_ref), to: :erlang
+  def read_timer(timer_ref) do
+    :erlang.read_timer(timer_ref)
+  end
 
-  @type spawn_opt ::
-          :link
-          | :monitor
-          | {:priority, :low | :normal | :high}
-          | {:fullsweep_after, non_neg_integer}
-          | {:min_heap_size, non_neg_integer}
-          | {:min_bin_vheap_size, non_neg_integer}
+  @type spawn_opt  :: :link | :monitor | {:priority, :low | :normal | :high} |
+                      {:fullsweep_after, non_neg_integer} |
+                      {:min_heap_size, non_neg_integer} |
+                      {:min_bin_vheap_size, non_neg_integer}
   @type spawn_opts :: [spawn_opt]
 
   @doc """
@@ -366,209 +297,157 @@ defmodule Process do
 
   The result depends on the given options. In particular,
   if `:monitor` is given as an option, it will return a tuple
-  containing the PID and the monitoring reference, otherwise
-  just the spawned process PID.
+  containing the pid and the monitoring reference, otherwise
+  just the spawned process pid.
 
-  More options are available; for the comprehensive list of available options
-  check `:erlang.spawn_opt/4`.
+  It also accepts extra options, for the list of available options
+  check [`:erlang.spawn_opt/4`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-4).
 
   Inlined by the compiler.
   """
   @spec spawn((() -> any), spawn_opts) :: pid | {pid, reference}
-  defdelegate spawn(fun, opts), to: :erlang, as: :spawn_opt
+  def spawn(fun, opts) do
+    :erlang.spawn_opt(fun, opts)
+  end
 
   @doc """
-  Spawns the given function `fun` from module `mod`, passing the given `args`
+  Spawns the given function from module `mod`, passing the given `args`
   according to the given options.
 
   The result depends on the given options. In particular,
   if `:monitor` is given as an option, it will return a tuple
-  containing the PID and the monitoring reference, otherwise
-  just the spawned process PID.
+  containing the pid and the monitoring reference, otherwise
+  just the spawned process pid.
 
   It also accepts extra options, for the list of available options
-  check `:erlang.spawn_opt/4`.
+  check [`:erlang.spawn_opt/4`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-4).
 
   Inlined by the compiler.
   """
   @spec spawn(module, atom, list, spawn_opts) :: pid | {pid, reference}
-  defdelegate spawn(mod, fun, args, opts), to: :erlang, as: :spawn_opt
+  def spawn(mod, fun, args, opts) do
+    :erlang.spawn_opt(mod, fun, args, opts)
+  end
 
   @doc """
-  Starts monitoring the given `item` from the calling process.
-
-  Once the monitored process dies, a message is delivered to the
-  monitoring process in the shape of:
-
-      {:DOWN, ref, :process, object, reason}
-
-  where:
-
-    * `ref` is a monitor reference returned by this function;
-    * `object` is either a `pid` of the monitored process (if monitoring
-      a PID) or `{name, node}` (if monitoring a remote or local name);
-    * `reason` is the exit reason.
-
-  If the process is already dead when calling `Process.monitor/1`, a
-  `:DOWN` message is delivered immediately.
+  The calling process starts monitoring the given `item`.
+  It returns the monitor reference.
 
   See [the need for monitoring](http://elixir-lang.org/getting-started/mix-otp/genserver.html#the-need-for-monitoring)
-  for an example. See `:erlang.monitor/2` for more info.
+  for an example.
+  See [`:erlang.monitor/2`](http://www.erlang.org/doc/man/erlang.html#monitor-2) for more info.
 
   Inlined by the compiler.
   """
-  @spec monitor(pid | {name :: atom, node :: atom} | name :: atom) :: reference
+  @spec monitor(pid | {reg_name :: atom, node :: atom} | reg_name :: atom) :: reference
   def monitor(item) do
     :erlang.monitor(:process, item)
   end
 
   @doc """
-  Demonitors the monitor identified by the given `reference`.
-
   If `monitor_ref` is a reference which the calling process
-  obtained by calling `monitor/1`, that monitoring is turned off.
+  obtained by calling `monitor/1`, this monitoring is turned off.
   If the monitoring is already turned off, nothing happens.
 
-  See `:erlang.demonitor/2` for more info.
+  See [`:erlang.demonitor/2`](http://www.erlang.org/doc/man/erlang.html#demonitor-2) for more info.
 
   Inlined by the compiler.
   """
+  @spec demonitor(reference) :: true
   @spec demonitor(reference, options :: [:flush | :info]) :: boolean
-  defdelegate demonitor(monitor_ref, options \\ []), to: :erlang
+  def demonitor(monitor_ref, options \\ []) do
+    :erlang.demonitor(monitor_ref, options)
+  end
 
   @doc """
-  Returns a list of PIDs corresponding to all the
+  Returns a list of process identifiers corresponding to all the
   processes currently existing on the local node.
 
-  Note that if a process is exiting, it is considered to exist but not be
-  alive. This means that for such process, `alive?/1` will return `false` but
-  its PID will be part of the list of PIDs returned by this function.
+  Note that a process that is exiting, exists but is not alive, i.e.,
+  `alive?/1` will return `false` for a process that is exiting,
+  but its process identifier will be part of the result returned.
 
-  See `:erlang.processes/0` for more info.
-
-  Inlined by the compiler.
+  See [`:erlang.processes/0`](http://www.erlang.org/doc/man/erlang.html#processes-0) for more info.
   """
-  @spec list() :: [pid]
-  defdelegate list(), to: :erlang, as: :processes
+  @spec list :: [pid]
+  def list do
+    :erlang.processes()
+  end
 
   @doc """
-  Creates a link between the calling process and the given item (process or
-  port).
+  Creates a link between the calling process and another process
+  (or port) `pid`, if there is not such a link already.
 
-  Links are bidirectional. Linked processes can be unlinked by using `unlink/1`.
-
-  If such a link exists already, this function does nothing since there can only
-  be one link between two given processes. If a process tries to create a link
-  to itself, nothing will happen.
-
-  When two processes are linked, each one receives exit signals from the other
-  (see also `exit/2`). Let's assume `pid1` and `pid2` are linked. If `pid2`
-  exits with a reason other than `:normal` (which is also the exit reason used
-  when a process finishes its job) and `pid1` is not trapping exits (see
-  `flag/2`), then `pid1` will exit with the same reason as `pid2` and in turn
-  emit an exit signal to all its other linked processes. The behaviour when
-  `pid1` is trapping exits is described in `exit/2`.
-
-  See `:erlang.link/1` for more info.
+  See [`:erlang.link/1`](http://www.erlang.org/doc/man/erlang.html#link-1) for more info.
 
   Inlined by the compiler.
   """
   @spec link(pid | port) :: true
-  defdelegate link(pid_or_port), to: :erlang
+  def link(pid) do
+    :erlang.link(pid)
+  end
 
   @doc """
-  Removes the link between the calling process and the given item (process or
-  port).
+  Removes the link, if there is one, between the calling process and
+  the process or port referred to by `pid`. Returns `true` and does not
+  fail, even if there is no link or `id` does not exist
 
-  If there is no such link, this function does nothing. If `pid_or_port` does
-  not exist, this function does not produce any errors and simply does nothing.
-
-  The return value of this function is always `true`.
-
-  See `:erlang.unlink/1` for more info.
+  See [`:erlang.unlink/1`](http://www.erlang.org/doc/man/erlang.html#unlink-1) for more info.
 
   Inlined by the compiler.
   """
   @spec unlink(pid | port) :: true
-  defdelegate unlink(pid_or_port), to: :erlang
-
-  @doc """
-  Registers the given `pid_or_port` under the given `name`.
-
-  `name` must be an atom and can then be used instead of the
-  PID/port identifier when sending messages with `Kernel.send/2`.
-
-  `register/2` will fail with `ArgumentError` in any of the following cases:
-
-    * the PID/Port is not existing locally and alive
-    * the name is already registered
-    * the `pid_or_port` is already registered under a different `name`
-
-  The following names are reserved and cannot be assigned to
-  processes nor ports:
-
-    * `nil`
-    * `false`
-    * `true`
-    * `:undefined`
-
-  """
-  @spec register(pid | port, atom) :: true
-  def register(pid_or_port, name)
-      when is_atom(name) and name not in [nil, false, true, :undefined] do
-    :erlang.register(name, pid_or_port)
-  catch
-    :error, :badarg when node(pid_or_port) != node() ->
-      message = "could not register #{inspect(pid_or_port)} because it belongs to another node"
-      :erlang.error(ArgumentError.exception(message), [pid_or_port, name])
-
-    :error, :badarg ->
-      message =
-        "could not register #{inspect(pid_or_port)} with " <>
-          "name #{inspect(name)} because it is not alive, the name is already " <>
-          "taken, or it has already been given another name"
-
-      :erlang.error(ArgumentError.exception(message), [pid_or_port, name])
+  def unlink(pid) do
+    :erlang.unlink(pid)
   end
 
   @doc """
-  Removes the registered `name`, associated with a PID
-  or a port identifier.
+  Associates the atom `name` with a `pid` or a port identifier.
 
-  Fails with `ArgumentError` if the name is not registered
-  to any PID or port.
-
-  Inlined by the compiler.
+  `name`, can then be used instead of the `pid` / port identifier with the `Kernel.send/2`
+  function. `Process.register/2` will fail with `ArgumentError` if the pid supplied
+  is no longer alive, (check with `alive?/1`) or if the name is already registered
+  (check with `whereis/1`) or if the `pid` is already registered to a different `name`.
   """
-  @spec unregister(atom) :: true
-  defdelegate unregister(name), to: :erlang
+  @spec register(pid | port, atom) :: true
+  def register(pid, name) when not name in [nil, false, true] and is_atom(name) do
+    :erlang.register(name, pid)
+  end
 
   @doc """
-  Returns the PID or port identifier registered under `name` or `nil` if the
-  name is not registered.
+  Removes the registered `name`, associated with a pid or a port identifier.
 
-  See `:erlang.whereis/1` for more info.
+  Fails with `ArgumentError` if the name is not registered to any pid or port.
+
+  See [`:erlang.unregister/1`](http://www.erlang.org/doc/man/erlang.html#unregister-1) for more info.
+  """
+  @spec unregister(atom) :: true
+  def unregister(name) do
+    :erlang.unregister(name)
+  end
+
+  @doc """
+  Returns the pid or port identifier with the registered `name`.
+  Returns `nil` if the name is not registered.
+
+  See [`:erlang.whereis/1`](http://www.erlang.org/doc/man/erlang.html#whereis-1) for more info.
   """
   @spec whereis(atom) :: pid | port | nil
   def whereis(name) do
-    nillify(:erlang.whereis(name))
+    nillify :erlang.whereis(name)
   end
 
   @doc """
-  Returns the PID of the group leader for the calling process.
-
-  Inlined by the compiler.
+  Returns the pid of the group leader for the process which evaluates the function.
   """
-  @spec group_leader() :: pid
-  defdelegate group_leader(), to: :erlang
+  @spec group_leader :: pid
+  def group_leader do
+    :erlang.group_leader
+  end
 
   @doc """
-  Sets the group leader of the given `pid` to `leader`.
-
-  Typically, this is used when a process started from a certain shell should
-  have a group leader other than `:init`.
-
-  Inlined by the compiler.
+  Sets the group leader of `pid` to `leader`. Typically, this is used when a processes
+  started from a certain shell should have a group leader other than `:init`.
   """
   @spec group_leader(pid, leader :: pid) :: true
   def group_leader(pid, leader) do
@@ -577,77 +456,57 @@ defmodule Process do
 
   @doc """
   Returns a list of names which have been registered using `register/2`.
-
-  Inlined by the compiler.
   """
-  @spec registered() :: [atom]
-  defdelegate registered(), to: :erlang
+  @spec registered :: [atom]
+  def registered do
+    :erlang.registered()
+  end
 
-  @typep heap_size ::
-           non_neg_integer
-           | %{size: non_neg_integer, kill: boolean, error_logger: boolean}
+  @typep process_flag :: :trap_exit | :error_handler | :min_heap_size |
+                         :min_bin_vheap_size | :priority | :save_calls |
+                         :sensitive
+  @doc """
+  Sets certain flags for the process which calls this function.
+  Returns the old value of the `flag`.
 
-  @typep priority_level :: :low | :normal | :high | :max
+  See [`:erlang.process_flag/2`](http://www.erlang.org/doc/man/erlang.html#process_flag-2) for more info.
+  """
+  @spec flag(process_flag, term) :: term
+  def flag(flag, value) do
+    :erlang.process_flag(flag, value)
+  end
 
   @doc """
-  Sets the given `flag` to `value` for the calling process.
+  Sets certain flags for the process `pid`, in the same manner as `flag/2`.
+  Returns the old value of the `flag`. The allowed values for `flag` are
+  only a subset of those allowed in `flag/2`, namely `:save_calls`.
 
-  Returns the old value of `flag`.
-
-  See `:erlang.process_flag/2` for more info.
-
-  Inlined by the compiler.
+  See [`:erlang.process_flag/3`](http://www.erlang.org/doc/man/erlang.html#process_flag-3) for more info.
   """
-  @spec flag(:error_handler, module) :: module
-  @spec flag(:max_heap_size, heap_size) :: heap_size
-  @spec flag(:message_queue_data, :erlang.message_queue_data()) :: :erlang.message_queue_data()
-  @spec flag(:min_bin_vheap_size, non_neg_integer) :: non_neg_integer
-  @spec flag(:min_heap_size, non_neg_integer) :: non_neg_integer
-  @spec flag(:monitor_nodes, term) :: term
-  @spec flag({:monitor_nodes, term()}, term) :: term
-  @spec flag(:priority, priority_level) :: priority_level
-  @spec flag(:save_calls, 0..10000) :: 0..10000
-  @spec flag(:sensitive, boolean) :: boolean
-  @spec flag(:trap_exit, boolean) :: boolean
-  defdelegate flag(flag, value), to: :erlang, as: :process_flag
-
-  @doc """
-  Sets the given `flag` to `value` for the given process `pid`.
-
-  Returns the old value of `flag`.
-
-  It raises `ArgumentError` if `pid` is not a local process.
-
-  The allowed values for `flag` are only a subset of those allowed in `flag/2`,
-  namely `:save_calls`.
-
-  See `:erlang.process_flag/3` for more info.
-
-  Inlined by the compiler.
-  """
-  @spec flag(pid, :save_calls, 0..10000) :: 0..10000
-  defdelegate flag(pid, flag, value), to: :erlang, as: :process_flag
+  @spec flag(pid, :save_calls, non_neg_integer) :: non_neg_integer
+  def flag(pid, flag, value) do
+    :erlang.process_flag(pid, flag, value)
+  end
 
   @doc """
   Returns information about the process identified by `pid`, or returns `nil` if the process
   is not alive.
-
   Use this only for debugging information.
 
-  See `:erlang.process_info/1` for more info.
+  See [`:erlang.process_info/1`](http://www.erlang.org/doc/man/erlang.html#process_info-1) for more info.
   """
-  @spec info(pid) :: keyword | nil
+  @spec info(pid) :: Keyword.t
   def info(pid) do
-    nillify(:erlang.process_info(pid))
+    nillify :erlang.process_info(pid)
   end
 
   @doc """
   Returns information about the process identified by `pid`,
   or returns `nil` if the process is not alive.
 
-  See `:erlang.process_info/2` for more info.
+  See [`:erlang.process_info/2`](http://www.erlang.org/doc/man/erlang.html#process_info-2) for more info.
   """
-  @spec info(pid, atom | [atom]) :: {atom, term} | [{atom, term}] | nil
+  @spec info(pid, atom | [atom]) :: {atom, term} | [{atom, term}]  | nil
   def info(pid, spec)
 
   def info(pid, :registered_name) do
@@ -659,25 +518,25 @@ defmodule Process do
   end
 
   def info(pid, spec) when is_atom(spec) or is_list(spec) do
-    nillify(:erlang.process_info(pid, spec))
+    nillify :erlang.process_info(pid, spec)
   end
 
   @doc """
-  Puts the calling process into a "hibernation" state.
-
-  The calling process is put into a waiting state
+  Puts the calling process into a wait state
   where its memory allocation has been reduced as much as possible,
   which is useful if the process does not expect to receive any messages
   in the near future.
 
-  See `:erlang.hibernate/3` for more info.
+  See [`:erlang.hibernate/3`](http://www.erlang.org/doc/man/erlang.html#hibernate-3) for more info.
 
   Inlined by the compiler.
   """
   @spec hibernate(module, atom, list) :: no_return
-  defdelegate hibernate(mod, fun_name, args), to: :erlang
+  def hibernate(mod, fun, args) do
+    :erlang.hibernate(mod, fun, args)
+  end
 
   @compile {:inline, nillify: 1}
   defp nillify(:undefined), do: nil
-  defp nillify(other), do: other
+  defp nillify(other),      do: other
 end

lib/elixir/lib/protocol.ex

@@ -19,38 +19,38 @@ defmodule Protocol do
   defmacro def({name, _, args}) when is_atom(name) and is_list(args) do
     arity = length(args)
 
-    type_args = :lists.map(fn _ -> quote(do: term) end, :lists.seq(2, arity))
+    type_args = :lists.map(fn _ -> quote(do: term) end,
+                           :lists.seq(2, arity))
     type_args = [quote(do: t) | type_args]
 
-    varify = fn pos -> Macro.var(String.to_atom("var" <> Integer.to_string(pos)), __MODULE__) end
-
-    call_args = :lists.map(varify, :lists.seq(2, arity))
-    call_args = [quote(do: term) | call_args]
+    call_args = :lists.map(fn i -> {String.to_atom(<<?x, i + 64>>), [], __MODULE__} end,
+                           :lists.seq(2, arity))
+    call_args = [quote(do: t) | call_args]
 
     quote do
-      name = unquote(name)
+      name  = unquote(name)
       arity = unquote(arity)
 
       @functions [{name, arity} | @functions]
 
       # Generate a fake definition with the user
       # signature that will be used by docs
-      Kernel.def(unquote(name)(unquote_splicing(args)))
+      Kernel.def unquote(name)(unquote_splicing(args))
 
       # Generate the actual implementation
       Kernel.def unquote(name)(unquote_splicing(call_args)) do
-        impl_for!(term).unquote(name)(unquote_splicing(call_args))
+        impl_for!(t).unquote(name)(unquote_splicing(call_args))
       end
 
       # Convert the spec to callback if possible,
       # otherwise generate a dummy callback
-      Module.spec_to_callback(__MODULE__, {name, arity}) ||
+      Protocol.__spec__?(__MODULE__, name, arity) ||
         @callback unquote(name)(unquote_splicing(type_args)) :: term
     end
   end
 
   defmacro def(_) do
-    raise ArgumentError, "invalid arguments for def inside defprotocol"
+    raise ArgumentError, "invalid args for def inside defprotocol"
   end
 
   @doc """
@@ -66,14 +66,14 @@ defmodule Protocol do
   defp assert_protocol!(module, extra) do
     case Code.ensure_compiled(module) do
       {:module, ^module} -> :ok
-      _ -> raise ArgumentError, "#{inspect(module)} is not available" <> extra
+      _ -> raise ArgumentError, "#{inspect module} is not available" <> extra
     end
 
     try do
       module.__protocol__(:module)
     rescue
       UndefinedFunctionError ->
-        raise ArgumentError, "#{inspect(module)} is not a protocol" <> extra
+        raise ArgumentError, "#{inspect module} is not a protocol" <> extra
     end
 
     :ok
@@ -95,76 +95,27 @@ defmodule Protocol do
 
     case Code.ensure_compiled(impl) do
       {:module, ^impl} -> :ok
-      _ -> raise ArgumentError, "#{inspect(impl)} is not available" <> extra
+      _ -> raise ArgumentError,
+             "#{inspect impl} is not available" <> extra
     end
 
     try do
       impl.__impl__(:protocol)
     rescue
       UndefinedFunctionError ->
-        raise ArgumentError, "#{inspect(impl)} is not an implementation of a protocol" <> extra
+        raise ArgumentError,
+          "#{inspect impl} is not an implementation of a protocol" <> extra
     else
       ^protocol ->
         :ok
-
       other ->
         raise ArgumentError,
-              "expected #{inspect(impl)} to be an implementation of #{inspect(protocol)}" <>
-                ", got: #{inspect(other)}" <> extra
+          "expected #{inspect impl} to be an implementation of #{inspect protocol}, got: #{inspect other}" <> extra
     end
   end
 
   @doc """
   Derives the `protocol` for `module` with the given options.
-
-  If your implementation passes options or if you are generating
-  custom code based on the struct, you will also need to implement
-  a macro defined as `__deriving__(module, struct, options)`
-  to get the options that were passed.
-
-  ## Examples
-
-      defprotocol Derivable do
-        def ok(a)
-      end
-
-      defimpl Derivable, for: Any do
-        defmacro __deriving__(module, struct, options) do
-          quote do
-            defimpl Derivable, for: unquote(module) do
-              def ok(arg) do
-                {:ok, arg, unquote(Macro.escape(struct)), unquote(options)}
-              end
-            end
-          end
-        end
-
-        def ok(arg) do
-          {:ok, arg}
-        end
-      end
-
-      defmodule ImplStruct do
-        @derive [Derivable]
-        defstruct a: 0, b: 0
-
-        defimpl Sample do
-          def ok(struct) do
-            Unknown.undefined(struct)
-          end
-        end
-      end
-
-  Explicit derivations can now be called via `__deriving__`:
-
-      # Explicitly derived via `__deriving__`
-      Derivable.ok(%ImplStruct{a: 1, b: 1})
-
-      # Explicitly derived by API via `__deriving__`
-      require Protocol
-      Protocol.derive(Derivable, ImplStruct, :oops)
-      Derivable.ok(%ImplStruct{a: 1, b: 1})
-
   """
   defmacro derive(protocol, module, options \\ []) do
     quote do
@@ -193,14 +144,15 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_protocols([charlist | String.t()]) :: [atom]
+  @spec extract_protocols([charlist | String.t]) :: [atom]
   def extract_protocols(paths) do
-    extract_matching_by_attribute(paths, 'Elixir.', fn module, attributes ->
-      case attributes[:protocol] do
-        [fallback_to_any: _] -> module
-        _ -> nil
+    extract_matching_by_attribute paths, 'Elixir.',
+      fn module, attributes ->
+        case attributes[:protocol] do
+          [fallback_to_any: _] -> module
+          _ -> nil
+        end
       end
-    end)
   end
 
   @doc """
@@ -222,23 +174,23 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_impls(module, [charlist | String.t()]) :: [atom]
+  @spec extract_impls(module, [charlist | String.t]) :: [atom]
   def extract_impls(protocol, paths) when is_atom(protocol) do
     prefix = Atom.to_charlist(protocol) ++ '.'
-
-    extract_matching_by_attribute(paths, prefix, fn _mod, attributes ->
-      case attributes[:protocol_impl] do
-        [protocol: ^protocol, for: for] -> for
-        _ -> nil
-      end
-    end)
+    extract_matching_by_attribute paths, prefix, fn
+      _mod, attributes ->
+        case attributes[:impl] do
+          [protocol: ^protocol, for: for] -> for
+          _ -> nil
+        end
+    end
   end
 
   defp extract_matching_by_attribute(paths, prefix, callback) do
     for path <- paths,
-        file <- list_dir(path),
-        mod = extract_from_file(path, file, prefix, callback),
-        do: mod
+       file <- list_dir(path),
+       mod = extract_from_file(path, file, prefix, callback),
+       do: mod
   end
 
   defp list_dir(path) when is_list(path) do
@@ -260,9 +212,8 @@ defmodule Protocol do
     case :beam_lib.chunks(file, [:attributes]) do
       {:ok, {module, [attributes: attributes]}} ->
         callback.(module, attributes)
-
-      _ ->
-        nil
+       _ ->
+         nil
     end
   end
 
@@ -299,39 +250,30 @@ defmodule Protocol do
   it will be loaded.
   """
   @spec consolidate(module, [module]) ::
-          {:ok, binary}
-          | {:error, :not_a_protocol}
-          | {:error, :no_beam_info}
+    {:ok, binary} |
+    {:error, :not_a_protocol} |
+    {:error, :no_beam_info}
   def consolidate(protocol, types) when is_atom(protocol) do
-    with {:ok, ast_info, chunks_info} <- beam_protocol(protocol),
-         {:ok, code} <- change_debug_info(ast_info, types),
-         do: compile(protocol, code, chunks_info)
+    with {:ok, info} <- beam_protocol(protocol),
+         {:ok, code, docs} <- change_debug_info(info, types),
+         do: compile(code, docs)
   end
 
+  @docs_chunk 'ExDc'
+
   defp beam_protocol(protocol) do
-    chunk_ids = [:abstract_code, :attributes, :compile_info, 'Docs', 'ExDp']
+    chunk_ids = [:abstract_code, :attributes, @docs_chunk]
     opts = [:allow_missing_chunks]
-
     case :beam_lib.chunks(beam_file(protocol), chunk_ids, opts) do
-      {:ok, {^protocol, entries}} ->
-        [
-          {:abstract_code, {_raw, abstract_code}},
-          {:attributes, attributes},
-          {:compile_info, compile_info} | extra_chunks
-        ] = entries
-
-        extra_chunks =
-          for {name, contents} when is_binary(contents) <- extra_chunks,
-              do: {List.to_string(name), contents}
-
+      {:ok, {^protocol, [{:abstract_code, {_raw, abstract_code}},
+                         {:attributes, attributes},
+                         {@docs_chunk, docs}]}} ->
         case attributes[:protocol] do
           [fallback_to_any: any] ->
-            {:ok, {protocol, any, abstract_code}, {compile_info, extra_chunks}}
-
+            {:ok, {protocol, any, abstract_code, docs}}
           _ ->
             {:error, :not_a_protocol}
         end
-
       _ ->
         {:error, :no_beam_info}
     end
@@ -339,155 +281,102 @@ defmodule Protocol do
 
   defp beam_file(module) when is_atom(module) do
     case :code.which(module) do
-      [_ | _] = file -> file
-      _ -> module
+      atom when is_atom(atom) -> module
+      file -> file
     end
   end
 
   # Change the debug information to the optimized
   # impl_for/1 dispatch version.
-  defp change_debug_info({protocol, any, code}, types) do
-    types = if any, do: types, else: List.delete(types, Any)
-    all = [Any] ++ for {_guard, mod} <- __builtin__(), do: mod
+  defp change_debug_info({protocol, any, code, docs}, types) do
+    types   = if any, do: types, else: List.delete(types, Any)
+    all     = [Any] ++ for {_guard, mod} <- __builtin__(), do: mod
     structs = types -- all
-
     case change_impl_for(code, protocol, types, structs, false, []) do
-      {:ok, ret} -> {:ok, ret}
-      other -> other
+      {:ok, ret} -> {:ok, ret, docs}
+      other      -> other
     end
   end
 
-  defp change_impl_for(
-         [{:function, line, :__protocol__, 1, clauses} | tail],
-         protocol,
-         types,
-         structs,
-         _,
-         acc
-       ) do
-    abstract_types = :erl_parse.abstract(:lists.usort(types))
+  defp change_impl_for([{:function, line, :__protocol__, 1, clauses} | t], protocol, types, structs, _, acc) do
+    clauses = :lists.map(fn
+      {:clause, l, [{:atom, _, :consolidated?}], [], [{:atom, _, _}]} ->
+        {:clause, l, [{:atom, 0, :consolidated?}], [], [{:atom, 0, true}]}
+      {:clause, _, _, _, _} = c ->
+        c
+    end, clauses)
 
-    clauses =
-      Enum.map(clauses, fn
-        {:clause, l, [{:atom, _, :consolidated?}], [], [{:atom, _, _}]} ->
-          {:clause, l, [{:atom, 0, :consolidated?}], [], [{:atom, 0, true}]}
-
-        {:clause, l, [{:atom, _, :impls}], [], [{:atom, _, _}]} ->
-          tuple = {:tuple, 0, [{:atom, 0, :consolidated}, abstract_types]}
-          {:clause, l, [{:atom, 0, :impls}], [], [tuple]}
-
-        {:clause, _, _, _, _} = c ->
-          c
-      end)
-
-    acc = [{:function, line, :__protocol__, 1, clauses} | acc]
-    change_impl_for(tail, protocol, types, structs, true, acc)
+    change_impl_for(t, protocol, types, structs, true,
+                    [{:function, line, :__protocol__, 1, clauses} | acc])
   end
 
-  defp change_impl_for(
-         [{:function, line, :impl_for, 1, _} | tail],
-         protocol,
-         types,
-         structs,
-         protocol?,
-         acc
-       ) do
+  defp change_impl_for([{:function, line, :impl_for, 1, _} | t], protocol, types, structs, is_protocol, acc) do
     fallback = if Any in types, do: load_impl(protocol, Any)
 
-    clauses =
-      for {guard, mod} <- __builtin__(),
-          mod in types,
-          do: builtin_clause_for(mod, guard, protocol, line)
+    clauses = for {guard, mod} <- __builtin__(),
+                  mod in types,
+                  do: builtin_clause_for(mod, guard, protocol, line)
 
-    clauses =
-      [struct_clause_for(line) | clauses] ++ [fallback_clause_for(fallback, protocol, line)]
+    clauses = [struct_clause_for(line) | clauses] ++
+              [fallback_clause_for(fallback, protocol, line)]
 
-    acc = [{:function, line, :impl_for, 1, clauses} | acc]
-    change_impl_for(tail, protocol, types, structs, protocol?, acc)
+    change_impl_for(t, protocol, types, structs, is_protocol,
+                    [{:function, line, :impl_for, 1, clauses} | acc])
   end
 
-  defp change_impl_for(
-         [{:function, line, :struct_impl_for, 1, _} | tail],
-         protocol,
-         types,
-         structs,
-         protocol?,
-         acc
-       ) do
+  defp change_impl_for([{:function, line, :struct_impl_for, 1, _} | t], protocol, types, structs, is_protocol, acc) do
     fallback = if Any in types, do: load_impl(protocol, Any)
     clauses = for struct <- structs, do: each_struct_clause_for(struct, protocol, line)
     clauses = clauses ++ [fallback_clause_for(fallback, protocol, line)]
 
-    acc = [{:function, line, :struct_impl_for, 1, clauses} | acc]
-    change_impl_for(tail, protocol, types, structs, protocol?, acc)
+    change_impl_for(t, protocol, types, structs, is_protocol,
+                    [{:function, line, :struct_impl_for, 1, clauses} | acc])
   end
 
-  defp change_impl_for(
-         [{:attribute, line, :spec, {{:__protocol__, 1}, funspecs}} | tail],
-         protocol,
-         types,
-         structs,
-         protocol?,
-         acc
-       ) do
-    new_specs =
-      for spec <- funspecs do
-        case spec do
-          {:type, line, :fun, [{:type, _, :product, [{:atom, _, :consolidated?}]}, _]} ->
-            product = {:type, line, :product, [{:atom, 0, :consolidated?}]}
-            {:type, line, :fun, [product, {:atom, 0, true}]}
-
-          {:type, line, :fun, [{:type, _, :product, [{:atom, _, :impls}]}, _]} ->
-            impls = for mod <- types, do: {:atom, 0, mod}
-            list = {:type, 0, :list, [{:type, 0, :union, impls}]}
-            tuple = {:type, 0, :tuple, [{:atom, 0, :consolidated}, list]}
-            {:type, line, :fun, [{:type, line, :product, [{:atom, 0, :impls}]}, tuple]}
-
-          other ->
-            other
-        end
-      end
-
-    acc = [{:attribute, line, :spec, {{:__protocol__, 1}, new_specs}} | acc]
-    change_impl_for(tail, protocol, types, structs, protocol?, acc)
+  defp change_impl_for([h | t], protocol, info, types, is_protocol, acc) do
+    change_impl_for(t, protocol, info, types, is_protocol, [h | acc])
   end
 
-  defp change_impl_for([head | tail], protocol, info, types, protocol?, acc) do
-    change_impl_for(tail, protocol, info, types, protocol?, [head | acc])
-  end
-
-  defp change_impl_for([], _protocol, _info, _types, protocol?, acc) do
-    if protocol? do
-      {:ok, Enum.reverse(acc)}
+  defp change_impl_for([], protocol, _info, _types, is_protocol, acc) do
+    if is_protocol do
+      {:ok, {protocol, Enum.reverse(acc)}}
     else
       {:error, :not_a_protocol}
     end
   end
 
   defp builtin_clause_for(mod, guard, protocol, line) do
-    remote = {:remote, line, {:atom, line, :erlang}, {:atom, line, guard}}
-    guard = {:call, line, remote, [{:var, line, :x}]}
-    body = {:atom, line, load_impl(protocol, mod)}
-    {:clause, line, [{:var, line, :x}], [[guard]], [body]}
+    {:clause, line,
+      [{:var, line, :x}],
+      [[{:call, line,
+          {:remote, line, {:atom, line, :erlang}, {:atom, line, guard}},
+          [{:var, line, :x}],
+     }]],
+      [{:atom, line, load_impl(protocol, mod)}]}
   end
 
   defp struct_clause_for(line) do
-    map_field_exact = {:map_field_exact, line, {:atom, line, :__struct__}, {:var, line, :x}}
-    arg = {:map, line, [map_field_exact]}
-
-    is_atom = {:remote, line, {:atom, line, :erlang}, {:atom, line, :is_atom}}
-    guard = {:call, line, is_atom, [{:var, line, :x}]}
-
-    body = {:call, line, {:atom, line, :struct_impl_for}, [{:var, line, :x}]}
-    {:clause, line, [arg], [[guard]], [body]}
+    {:clause, line,
+      [{:map, line, [
+        {:map_field_exact, line, {:atom, line, :__struct__}, {:var, line, :x}}
+      ]}],
+      [[{:call, line,
+          {:remote, line, {:atom, line, :erlang}, {:atom, line, :is_atom}},
+          [{:var, line, :x}],
+     }]],
+      [{:call, line,
+          {:atom, line, :struct_impl_for},
+          [{:var, line, :x}]}]}
   end
 
-  defp each_struct_clause_for(struct, protocol, line) do
-    {:clause, line, [{:atom, line, struct}], [], [{:atom, line, load_impl(protocol, struct)}]}
+  defp each_struct_clause_for(other, protocol, line) do
+    {:clause, line, [{:atom, line, other}], [],
+      [{:atom, line, load_impl(protocol, other)}]}
   end
 
   defp fallback_clause_for(value, _protocol, line) do
-    {:clause, line, [{:var, line, :_}], [], [{:atom, line, value}]}
+    {:clause, line, [{:var, line, :_}], [],
+      [{:atom, line, value}]}
   end
 
   defp load_impl(protocol, for) do
@@ -495,31 +384,27 @@ defmodule Protocol do
   end
 
   # Finally compile the module and emit its bytecode.
-  defp compile(protocol, code, {compile_info, extra_chunks}) do
-    opts = Keyword.take(compile_info, [:source])
-    opts = if Code.compiler_options()[:debug_info], do: [:debug_info | opts], else: opts
+  defp compile({protocol, code}, docs) do
+    opts = if Code.compiler_options[:debug_info], do: [:debug_info], else: []
     {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return | opts])
-    {:ok, :elixir_erl.add_beam_chunks(binary, extra_chunks)}
+    {:ok,
+      case docs do
+        :missing_chunk -> binary
+        _ -> :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
+      end}
   end
 
   ## Definition callbacks
 
   @doc false
-  def __protocol__(name, do: block) do
+  def __protocol__(name, [do: block]) do
     quote do
       defmodule unquote(name) do
         # We don't allow function definition inside protocols
-        import Kernel,
-          except: [
-            defmacrop: 1,
-            defmacrop: 2,
-            defmacro: 1,
-            defmacro: 2,
-            defp: 1,
-            defp: 2,
-            def: 1,
-            def: 2
-          ]
+        import Kernel, except: [
+          defmacrop: 1, defmacrop: 2, defmacro: 1, defmacro: 2,
+          defp: 1, defp: 2, def: 1, def: 2
+        ]
 
         # Import the new dsl that holds the new def
         import Protocol, only: [def: 1]
@@ -535,23 +420,16 @@ defmodule Protocol do
         _ = unquote(block)
 
         # Finalize expansion
-        unquote(after_defprotocol())
+        unquote(after_defprotocol)
       end
     end
   end
 
   defp after_defprotocol do
     quote bind_quoted: [builtin: __builtin__()] do
-      any_impl_for =
-        if @fallback_to_any do
-          quote do: unquote(__MODULE__.Any).__impl__(:target)
-        else
-          nil
-        end
-
       @doc false
       @spec impl_for(term) :: atom | nil
-      Kernel.def(impl_for(data))
+      Kernel.def impl_for(data)
 
       # Define the implementation for structs.
       #
@@ -561,58 +439,50 @@ defmodule Protocol do
         struct_impl_for(struct)
       end
 
-      # Define the implementation for built-ins
-      :lists.foreach(
-        fn {guard, mod} ->
-          target = Module.concat(__MODULE__, mod)
+      # Define the implementation for builtins.
+      :lists.foreach(fn {guard, mod} ->
+        target = Module.concat(__MODULE__, mod)
 
-          Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
-            case Code.ensure_compiled?(unquote(target)) and
-                   function_exported?(unquote(target), :__impl__, 1) do
-              true -> unquote(target).__impl__(:target)
-              false -> unquote(any_impl_for)
-            end
+        Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
+          case impl_for?(unquote(target)) do
+            true  -> unquote(target).__impl__(:target)
+            false -> any_impl_for
           end
-        end,
-        builtin
-      )
-
-      # Define a catch-all impl_for/1 clause to pacify Dialyzer (since
-      # destructuring opaque types is illegal, Dialyzer will think none of the
-      # previous clauses matches opaque types, and without this clause, will
-      # conclude that impl_for can't handle an opaque argument). This is a hack
-      # since it relies on Dialyzer not being smart enough to conclude that all
-      # opaque types will get the any_impl_for/0 implementation.
-      Kernel.def impl_for(_) do
-        unquote(any_impl_for)
-      end
+        end
+      end, builtin)
 
       @doc false
-      @spec impl_for!(term) :: atom
-      if any_impl_for do
-        Kernel.def impl_for!(data) do
-          impl_for(data)
-        end
+      @spec impl_for!(term) :: atom | no_return
+      Kernel.def impl_for!(data) do
+        impl_for(data) || raise(Protocol.UndefinedError, protocol: __MODULE__, value: data)
+      end
+
+      # Internal handler for Any
+      if @fallback_to_any do
+        Kernel.defp any_impl_for, do: __MODULE__.Any.__impl__(:target)
       else
-        Kernel.def impl_for!(data) do
-          impl_for(data) || raise(Protocol.UndefinedError, protocol: __MODULE__, value: data)
-        end
+        Kernel.defp any_impl_for, do: nil
       end
 
       # Internal handler for Structs
       Kernel.defp struct_impl_for(struct) do
         target = Module.concat(__MODULE__, struct)
-
-        case Code.ensure_compiled?(target) and function_exported?(target, :__impl__, 1) do
-          true -> target.__impl__(:target)
-          false -> unquote(any_impl_for)
+        case impl_for?(target) do
+          true  -> target.__impl__(:target)
+          false -> any_impl_for
         end
       end
 
-      # Inline struct implementation for performance
-      @compile {:inline, struct_impl_for: 1}
+      # Check if compilation is available internally
+      Kernel.defp impl_for?(target) do
+        Code.ensure_compiled?(target) and
+          function_exported?(target, :__impl__, 1)
+      end
 
-      unless Module.defines_type?(__MODULE__, {:t, 0}) do
+      # Inline any and struct implementations
+      @compile {:inline, any_impl_for: 0, struct_impl_for: 1, impl_for?: 1}
+
+      unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
         @type t :: term
       end
 
@@ -624,31 +494,29 @@ defmodule Protocol do
       @doc false
       @spec __protocol__(:module) :: __MODULE__
       @spec __protocol__(:functions) :: unquote(Protocol.__functions_spec__(@functions))
-      @spec __protocol__(:consolidated?) :: false
-      @spec __protocol__(:impls) :: :not_consolidated
-      Kernel.def(__protocol__(:module), do: __MODULE__)
-      Kernel.def(__protocol__(:functions), do: unquote(:lists.sort(@functions)))
-      Kernel.def(__protocol__(:consolidated?), do: false)
-      Kernel.def(__protocol__(:impls), do: :not_consolidated)
+      @spec __protocol__(:consolidated?) :: boolean
+      Kernel.def __protocol__(:module), do: __MODULE__
+      Kernel.def __protocol__(:functions), do: unquote(:lists.sort(@functions))
+      Kernel.def __protocol__(:consolidated?), do: false
     end
   end
 
   @doc false
-  def __functions_spec__([]), do: []
-
-  def __functions_spec__([head | tail]),
-    do: [:lists.foldl(&{:|, [], [&1, &2]}, head, tail), quote(do: ...)]
+  def __functions_spec__([]),
+    do: []
+  def __functions_spec__([h | t]),
+    do: [:lists.foldl(&{:|, [], [&1, &2]}, h, t), quote(do: ...)]
 
   @doc false
   def __impl__(protocol, opts) do
     do_defimpl(protocol, :lists.keysort(1, opts))
   end
 
-  defp do_defimpl(protocol, do: block, for: for) when is_list(for) do
-    for f <- for, do: do_defimpl(protocol, do: block, for: f)
+  defp do_defimpl(protocol, [do: block, for: for]) when is_list(for) do
+    for f <- for, do: do_defimpl(protocol, [do: block, for: f])
   end
 
-  defp do_defimpl(protocol, do: block, for: for) do
+  defp do_defimpl(protocol, [do: block, for: for]) do
     # Unquote the implementation just later
     # when all variables will already be injected
     # into the module body.
@@ -658,28 +526,28 @@ defmodule Protocol do
         @spec __impl__(:for) :: unquote(for)
         @spec __impl__(:target) :: __MODULE__
         @spec __impl__(:protocol) :: unquote(protocol)
-        def __impl__(:for), do: unquote(for)
-        def __impl__(:target), do: __MODULE__
+        def __impl__(:for),      do: unquote(for)
+        def __impl__(:target),   do: __MODULE__
         def __impl__(:protocol), do: unquote(protocol)
       end
 
     quote do
       protocol = unquote(protocol)
-      for = unquote(for)
-      name = Module.concat(protocol, for)
+      for      = unquote(for)
+      name     = Module.concat(protocol, for)
 
       Protocol.assert_protocol!(protocol)
       Protocol.__ensure_defimpl__(protocol, for, __ENV__)
 
       defmodule name do
         @behaviour protocol
-        @protocol protocol
-        @for for
+        @protocol  protocol
+        @for       for
 
         unquote(block)
 
-        Module.register_attribute(__MODULE__, :protocol_impl, persist: true)
-        @protocol_impl [protocol: @protocol, for: @for]
+        Module.register_attribute(__MODULE__, :impl, persist: true)
+        @impl [protocol: @protocol, for: @for]
 
         unquote(impl)
       end
@@ -690,55 +558,51 @@ defmodule Protocol do
   def __derive__(derives, for, %Macro.Env{} = env) when is_atom(for) do
     struct =
       if for == env.module do
-        Module.get_attribute(for, :struct) || raise "struct is not defined for #{inspect(for)}"
+        Module.get_attribute(for, :struct) ||
+          raise "struct is not defined for #{inspect for}"
       else
         for.__struct__
       end
 
-    foreach = fn
+    :lists.foreach(fn
       proto when is_atom(proto) ->
         derive(proto, for, struct, [], env)
-
       {proto, opts} when is_atom(proto) ->
         derive(proto, for, struct, opts, env)
-    end
-
-    :lists.foreach(foreach, :lists.flatten(derives))
+    end, :lists.flatten(derives))
 
     :ok
   end
 
   defp derive(protocol, for, struct, opts, env) do
-    extra = ", cannot derive #{inspect(protocol)} for #{inspect(for)}"
+    extra = ", cannot derive #{inspect protocol} for #{inspect for}"
     assert_protocol!(protocol, extra)
     __ensure_defimpl__(protocol, for, env)
     assert_impl!(protocol, Any, extra)
 
     # Clean up variables from eval context
-    env = :elixir_env.reset_vars(env)
+    env  = %{env | vars: [], export_vars: nil}
     args = [for, struct, opts]
     impl = Module.concat(protocol, Any)
 
-    :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn mod, fun, args ->
-      if function_exported?(mod, fun, length(args)) do
-        apply(mod, fun, args)
-      else
-        quoted =
-          quote do
-            Module.register_attribute(__MODULE__, :protocol_impl, persist: true)
-            @protocol_impl [protocol: unquote(protocol), for: unquote(for)]
+    :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn
+      mod, fun, args ->
+        if function_exported?(mod, fun, length(args)) do
+          apply(mod, fun, args)
+        else
+          Module.create(Module.concat(protocol, for), quote do
+            Module.register_attribute(__MODULE__, :impl, persist: true)
+            @impl [protocol: unquote(protocol), for: unquote(for)]
 
             @doc false
             @spec __impl__(:target) :: unquote(impl)
             @spec __impl__(:protocol) :: unquote(protocol)
             @spec __impl__(:for) :: unquote(for)
-            def __impl__(:target), do: unquote(impl)
+            def __impl__(:target),   do: unquote(impl)
             def __impl__(:protocol), do: unquote(protocol)
-            def __impl__(:for), do: unquote(for)
-          end
-
-        Module.create(Module.concat(protocol, for), quoted, Macro.Env.location(env))
-      end
+            def __impl__(:for),      do: unquote(for)
+          end, Macro.Env.location(env))
+        end
     end)
   end
 
@@ -746,33 +610,43 @@ defmodule Protocol do
   def __ensure_defimpl__(protocol, for, env) do
     if Protocol.consolidated?(protocol) do
       message =
-        "the #{inspect(protocol)} protocol has already been consolidated, an " <>
-          "implementation for #{inspect(for)} has no effect. If you want to " <>
-          "implement protocols after compilation or during tests, check the " <>
-          "\"Consolidation\" section in the documentation for Kernel.defprotocol/2"
-
+        "the #{inspect protocol} protocol has already been consolidated" <>
+        ", an implementation for #{inspect for} has no effect"
       :elixir_errors.warn(env.line, env.file, message)
     end
-
     :ok
   end
 
+  @doc false
+  def __spec__?(module, name, arity) do
+    signature = {name, arity}
+
+    specs = Module.get_attribute(module, :spec)
+    found =
+      :lists.map(fn {:spec, expr, caller} ->
+        if Kernel.Typespec.spec_to_signature(expr) == signature do
+          Kernel.Typespec.define_spec(:callback, expr, caller)
+          true
+        end
+      end, specs)
+
+    :lists.any(& &1 == true, found)
+  end
+
   ## Helpers
 
   @doc false
   def __builtin__ do
-    [
-      is_tuple: Tuple,
-      is_atom: Atom,
-      is_list: List,
-      is_map: Map,
-      is_bitstring: BitString,
-      is_integer: Integer,
-      is_float: Float,
-      is_function: Function,
-      is_pid: PID,
-      is_port: Port,
-      is_reference: Reference
-    ]
+    [is_tuple: Tuple,
+     is_atom: Atom,
+     is_list: List,
+     is_map: Map,
+     is_bitstring: BitString,
+     is_integer: Integer,
+     is_float: Float,
+     is_function: Function,
+     is_pid: PID,
+     is_port: Port,
+     is_reference: Reference]
   end
 end

lib/elixir/lib/range.ex

@@ -5,13 +5,13 @@ defmodule Range do
   A range represents a discrete number of values where
   the first and last values are integers.
 
-  Ranges can be either increasing (`first <= last`) or
-  decreasing (`first > last`). Ranges are also always
+  Ranges can be either increasing (first <= last) or
+  decreasing (first > last). Ranges are also always
   inclusive.
 
-  A range is represented internally as a struct. However,
+  A Range is represented internally as a struct. However,
   the most common form of creating and matching on ranges
-  is via the `../2` macro, auto-imported from `Kernel`:
+  is via the `../2` macro, auto-imported from Kernel:
 
       iex> range = 1..3
       1..3
@@ -21,9 +21,8 @@ defmodule Range do
       iex> last
       3
 
-  A range implements the `Enumerable` protocol, which means
-  functions in the `Enum` module can be used to work with
-  ranges:
+  A Range implements the Enumerable protocol, which means
+  all of the functions in the Enum module is available:
 
       iex> range = 1..10
       1..10
@@ -43,6 +42,7 @@ defmodule Range do
   @type t :: %Range{first: integer, last: integer}
   @type t(first, last) :: %Range{first: first, last: last}
 
+
   @doc """
   Creates a new range.
   """
@@ -53,13 +53,23 @@ defmodule Range do
 
   def new(first, last) do
     raise ArgumentError,
-          "ranges (first..last) expect both sides to be integers, " <>
-            "got: #{inspect(first)}..#{inspect(last)}"
+      "ranges (first..last) expect both sides to be integers, " <>
+      "got: #{inspect first}..#{inspect last}"
   end
 
-  # TODO: Remove by 2.0
-  @doc false
-  @deprecated "Pattern match on first..last instead"
+  @doc """
+  Returns `true` if the given `term` is a valid range.
+
+  ## Examples
+
+      iex> Range.range?(1..3)
+      true
+
+      iex> Range.range?(0)
+      false
+
+  """
+  @spec range?(term) :: boolean
   def range?(term)
   def range?(first..last) when is_integer(first) and is_integer(last), do: true
   def range?(_), do: false
@@ -67,23 +77,23 @@ end
 
 defimpl Enumerable, for: Range do
   def reduce(first..last, acc, fun) do
-    reduce(first, last, acc, fun, _up? = last >= first)
+    reduce(first, last, acc, fun, last >= first)
   end
 
-  defp reduce(_first, _last, {:halt, acc}, _fun, _up?) do
+  defp reduce(_x, _y, {:halt, acc}, _fun, _up) do
     {:halted, acc}
   end
 
-  defp reduce(first, last, {:suspend, acc}, fun, up?) do
-    {:suspended, acc, &reduce(first, last, &1, fun, up?)}
+  defp reduce(x, y, {:suspend, acc}, fun, up) do
+    {:suspended, acc, &reduce(x, y, &1, fun, up)}
   end
 
-  defp reduce(first, last, {:cont, acc}, fun, _up? = true) when first <= last do
-    reduce(first + 1, last, fun.(first, acc), fun, _up? = true)
+  defp reduce(x, y, {:cont, acc}, fun, true) when x <= y do
+    reduce(x + 1, y, fun.(x, acc), fun, true)
   end
 
-  defp reduce(first, last, {:cont, acc}, fun, _up? = false) when first >= last do
-    reduce(first - 1, last, fun.(first, acc), fun, _up? = false)
+  defp reduce(x, y, {:cont, acc}, fun, false) when x >= y do
+    reduce(x - 1, y, fun.(x, acc), fun, false)
   end
 
   defp reduce(_, _, {:cont, acc}, _fun, _up) do
@@ -109,26 +119,12 @@ defimpl Enumerable, for: Range do
       {:ok, first - last + 1}
     end
   end
-
-  def slice(first..last) do
-    if first <= last do
-      {:ok, last - first + 1, &slice_asc(first + &1, &2)}
-    else
-      {:ok, first - last + 1, &slice_desc(first - &1, &2)}
-    end
-  end
-
-  defp slice_asc(current, 1), do: [current]
-  defp slice_asc(current, remaining), do: [current | slice_asc(current + 1, remaining - 1)]
-
-  defp slice_desc(current, 1), do: [current]
-  defp slice_desc(current, remaining), do: [current | slice_desc(current - 1, remaining - 1)]
 end
 
 defimpl Inspect, for: Range do
   import Inspect.Algebra
 
   def inspect(first..last, opts) do
-    concat([to_doc(first, opts), "..", to_doc(last, opts)])
+    concat [to_doc(first, opts), "..", to_doc(last, opts)]
   end
 end

lib/elixir/lib/record.ex

@@ -1,10 +1,10 @@
 defmodule Record do
   @moduledoc """
-  Module to work with, define, and import records.
+  Module to work with, define and import records.
 
   Records are simply tuples where the first element is an atom:
 
-      iex> Record.is_record({User, "john", 27})
+      iex> Record.is_record {User, "john", 27}
       true
 
   This module provides conveniences for working with records at
@@ -17,14 +17,15 @@ defmodule Record do
     1. to work with short, internal data
     2. to interface with Erlang records
 
-  The macros `defrecord/3` and `defrecordp/3` can be used to create records
-  while `extract/2` and `extract_all/1` can be used to extract records from
-  Erlang files.
+  The macros `defrecord/3` and `defrecordp/3` can be used to create
+  records while `extract/2` can be used to extract records from Erlang
+  files.
 
   ## Types
 
-  Types can be defined for tuples with the `record/2` macro (only available in
-  typespecs). This macro will expand to a tuple as seen in the example below:
+  Types can be defined for tuples with the `record/2` macro (only available
+  in typespecs). Like with the generated record macros it will expand to
+  a tuple.
 
       defmodule MyModule do
         require Record
@@ -33,43 +34,14 @@ defmodule Record do
         @type user :: record(:user, name: String.t, age: integer)
         # expands to: "@type user :: {:user, String.t, integer}"
       end
-
   """
 
   @doc """
   Extracts record information from an Erlang file.
 
   Returns a quoted expression containing the fields as a list
-  of tuples.
-
-  `name`, which is the name of the extracted record, is expected to be an atom
-  *at compile time*.
-
-  ## Options
-
-  This function accepts the following options, which are exclusive to each other
-  (i.e., only one of them can be used in the same call):
-
-    * `:from` - (binary representing a path to a file) path to the Erlang file
-      that contains the record definition to extract; with this option, this
-      function uses the same path lookup used by the `-include` attribute used in
-      Erlang modules.
-
-    * `:from_lib` - (binary representing a path to a file) path to the Erlang
-      file that contains the record definition to extract; with this option,
-      this function uses the same path lookup used by the `-include_lib`
-      attribute used in Erlang modules.
-
-    * `:includes` - (a list of directories as binaries) if the record being
-      extracted depends on relative includes, this option allows developers
-      to specify the directory those relative includes exist
-
-    * `:macros` - (keyword list of macro names and values) if the record
-      being extract depends on the values of macros, this option allows
-      the value of those macros to be set
-
-  These options are expected to be literals (including the binary values) at
-  compile time.
+  of tuples. It expects the record name to be an atom and the
+  library path to be a string at expansion time.
 
   ## Examples
 
@@ -80,7 +52,6 @@ defmodule Record do
        uid: :undefined, gid: :undefined]
 
   """
-  @spec extract(name :: atom, keyword) :: keyword
   def extract(name, opts) when is_atom(name) and is_list(opts) do
     Record.Extractor.extract(name, opts)
   end
@@ -88,34 +59,18 @@ defmodule Record do
   @doc """
   Extracts all records information from an Erlang file.
 
-  Returns a keyword list of `{record_name, fields}` tuples where `record_name`
-  is the name of an extracted record and `fields` is a list of `{field, value}`
-  tuples representing the fields for that record.
+  Returns a keyword list containing extracted record names as keys, and
+  lists of tuples describing the fields as values. It expects a named
+  argument :from or :from_lib, which correspond to *include* or
+  *include_lib* attribute from Erlang modules, respectively.
 
-  ## Options
-
-  This function accepts the following options, which are exclusive to each other
-  (i.e., only one of them can be used in the same call):
-
-    * `:from` - (binary representing a path to a file) path to the Erlang file
-      that contains the record definitions to extract; with this option, this
-      function uses the same path lookup used by the `-include` attribute used in
-      Erlang modules.
-    * `:from_lib` - (binary representing a path to a file) path to the Erlang
-      file that contains the record definitions to extract; with this option,
-      this function uses the same path lookup used by the `-include_lib`
-      attribute used in Erlang modules.
-
-  These options are expected to be literals (including the binary values) at
-  compile time.
   """
-  @spec extract_all(keyword) :: [{name :: atom, keyword}]
   def extract_all(opts) when is_list(opts) do
     Record.Extractor.extract_all(opts)
   end
 
   @doc """
-  Checks if the given `data` is a record of kind `kind`.
+  Checks if the given `data` is a record of `kind`.
 
   This is implemented as a macro so it can be used in guard clauses.
 
@@ -126,9 +81,21 @@ defmodule Record do
       true
 
   """
-  defguard is_record(data, kind)
-           when is_atom(kind) and is_tuple(data) and tuple_size(data) > 0 and
-                  elem(data, 0) == kind
+  defmacro is_record(data, kind) do
+    case Macro.Env.in_guard?(__CALLER__) do
+      true ->
+        quote do
+          is_atom(unquote(kind)) and is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0 and
+            elem(unquote(data), 0) == unquote(kind)
+        end
+      false ->
+        quote do
+          result = unquote(data)
+          kind = unquote(kind)
+          is_atom(kind) and is_tuple(result) and tuple_size(result) > 0 and elem(result, 0) == kind
+        end
+    end
+  end
 
   @doc """
   Checks if the given `data` is a record.
@@ -145,31 +112,27 @@ defmodule Record do
       false
 
   """
-  defguard is_record(data)
-           when is_tuple(data) and tuple_size(data) > 0 and is_atom(elem(data, 0))
+  defmacro is_record(data) do
+    case Macro.Env.in_guard?(__CALLER__) do
+      true ->
+        quote do
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0 and
+            is_atom(elem(unquote(data), 0))
+        end
+      false ->
+        quote do
+          result = unquote(data)
+          is_tuple(result) and tuple_size(result) > 0 and is_atom(elem(result, 0))
+        end
+    end
+  end
 
   @doc """
-  Defines a set of macros to create, access, and pattern match
-  on a record.
+  Defines a set of macros to create and access a record.
 
-  The name of the generated macros will be `name` (which has to be an
-  atom). `tag` is also an atom and is used as the "tag" for the record (i.e.,
-  the first element of the record tuple); by default (if `nil`), it's the same
-  as `name`. `kv` is a keyword list of `name: default_value` fields for the
-  new record.
-
-  The following macros are generated:
-
-    * `name/0` to create a new record with default values for all fields
-    * `name/1` to create a new record with the given fields and values,
-      to get the zero-based index of the given field in a record or to
-      convert the given record to a keyword list
-    * `name/2` to update an existing record with the given fields and values
-      or to access a given field in a given record
-
-  All these macros are public macros (as defined by `defmacro`).
-
-  See the "Examples" section for examples on how to use these macros.
+  The macros are going to have `name`, a tag (which defaults)
+  to the name if none is given, and a set of fields given by
+  `kv`.
 
   ## Examples
 
@@ -179,10 +142,7 @@ defmodule Record do
       end
 
   In the example above, a set of macros named `user` but with different
-  arities will be defined to manipulate the underlying record.
-
-      # Import the module to make the user macros locally available
-      import User
+  arities will be defined to manipulate the underlying record:
 
       # To create records
       record = user()        #=> {:user, "meg", 25}
@@ -194,10 +154,6 @@ defmodule Record do
       # To update the record
       user(record, age: 26) #=> {:user, "meg", 26}
 
-      # To get the zero-based index of the field in record tuple
-      # (index 0 is occupied by the record "tag")
-      user(:name) #=> 1
-
       # Convert a record to a keyword list
       user(record) #=> [name: "meg", age: 26]
 
@@ -209,28 +165,27 @@ defmodule Record do
       user(name: name) = record
       name #=> "meg"
 
-  By default, Elixir uses the record name as the first element of the tuple (the "tag").
-  However, a different tag can be specified when defining a record,
-  as in the following example, in which we use `Customer` as the second argument of `defrecord/3`:
+  By default, Elixir uses the record name as the first element of
+  the tuple (the tag). But it can be changed to something else:
 
       defmodule User do
         require Record
-        Record.defrecord :user, Customer, name: nil
+        Record.defrecord :user, User, name: nil
       end
 
       require User
-      User.user() #=> {Customer, nil}
+      User.user() #=> {User, nil}
 
-  ## Defining extracted records with anonymous functions in the values
+  ## Defining extracted records with anonymous functions
 
-  If a record defines an anonymous function in the default values, an
-  `ArgumentError` will be raised. This can happen unintentionally when defining
-  a record after extracting it from an Erlang library that uses anonymous
-  functions for defaults.
+  If a record defines an anonymous function, an `ArgumentError`
+  will occur if you attempt to create a record with it.
+  This can occur unintentionally when defining a record after extracting
+  it from an Erlang library that uses anonymous functions for defaults.
 
       Record.defrecord :my_rec, Record.extract(...)
       #=> ** (ArgumentError) invalid value for record field fun_field,
-      #=>   cannot escape #Function<12.90072148/2 in :erl_eval.expr/5>.
+      cannot escape #Function<12.90072148/2 in :erl_eval.expr/5>.
 
   To work around this error, redefine the field with your own &M.f/a function,
   like so:
@@ -240,18 +195,17 @@ defmodule Record do
         Record.defrecord :my_rec, Record.extract(...) |> Keyword.merge(fun_field: &__MODULE__.foo/2)
         def foo(bar, baz), do: IO.inspect({bar, baz})
       end
-
   """
   defmacro defrecord(name, tag \\ nil, kv) do
     quote bind_quoted: [name: name, tag: tag, kv: kv] do
       tag = tag || name
       fields = Record.__fields__(:defrecord, kv)
 
-      defmacro unquote(name)(args \\ []) do
+      defmacro(unquote(name)(args \\ [])) do
         Record.__access__(unquote(tag), unquote(fields), args, __CALLER__)
       end
 
-      defmacro unquote(name)(record, args) do
+      defmacro(unquote(name)(record, args)) do
         Record.__access__(unquote(tag), unquote(fields), record, args, __CALLER__)
       end
     end
@@ -265,11 +219,11 @@ defmodule Record do
       tag = tag || name
       fields = Record.__fields__(:defrecordp, kv)
 
-      defmacrop unquote(name)(args \\ []) do
+      defmacrop(unquote(name)(args \\ [])) do
         Record.__access__(unquote(tag), unquote(fields), args, __CALLER__)
       end
 
-      defmacrop unquote(name)(record, args) do
+      defmacrop(unquote(name)(record, args)) do
         Record.__access__(unquote(tag), unquote(fields), record, args, __CALLER__)
       end
     end
@@ -278,88 +232,74 @@ defmodule Record do
   # Normalizes of record fields to have default values.
   @doc false
   def __fields__(type, fields) do
-    normalizer_fun = fn
-      {key, value} when is_atom(key) ->
+    :lists.map(fn
+      {key, val} when is_atom(key) ->
         try do
-          Macro.escape(value)
+          Macro.escape(val)
         rescue
           e in [ArgumentError] ->
             raise ArgumentError, "invalid value for record field #{key}, " <> Exception.message(e)
         else
-          value -> {key, value}
+          val -> {key, val}
         end
-
       key when is_atom(key) ->
         {key, nil}
-
       other ->
-        raise ArgumentError, "#{type} fields must be atoms, got: #{inspect(other)}"
-    end
-
-    :lists.map(normalizer_fun, fields)
+        raise ArgumentError, "#{type} fields must be atoms, got: #{inspect other}"
+    end, fields)
   end
 
   # Callback invoked from record/0 and record/1 macros.
   @doc false
-  def __access__(tag, fields, args, caller) do
+  def __access__(atom, fields, args, caller) do
     cond do
       is_atom(args) ->
-        index(tag, fields, args)
-
+        index(atom, fields, args)
       Keyword.keyword?(args) ->
-        create(tag, fields, args, caller)
-
+        create(atom, fields, args, caller)
       true ->
-        fields = Macro.escape(fields)
-
         case Macro.expand(args, caller) do
-          {:{}, _, [^tag | list]} when length(list) == length(fields) ->
-            record = List.to_tuple([tag | list])
-            Record.__keyword__(tag, fields, record)
-
-          {^tag, arg} when length(fields) == 1 ->
-            Record.__keyword__(tag, fields, {tag, arg})
-
+          {:{}, _, [^atom | list]} when length(list) == length(fields) ->
+            record = List.to_tuple([atom | list])
+            Macro.escape(Record.__keyword__(atom, fields, record))
+          {^atom, arg} when length(fields) == 1 ->
+            Macro.escape(Record.__keyword__(atom, fields, {atom, arg}))
           _ ->
-            quote(do: Record.__keyword__(unquote(tag), unquote(fields), unquote(args)))
+            quote do: Record.__keyword__(unquote(atom), unquote(fields), unquote(args))
         end
     end
   end
 
   # Callback invoked from the record/2 macro.
   @doc false
-  def __access__(tag, fields, record, args, caller) do
+  def __access__(atom, fields, record, args, caller) do
     cond do
       is_atom(args) ->
-        get(tag, fields, record, args)
-
+        get(atom, fields, record, args)
       Keyword.keyword?(args) ->
-        update(tag, fields, record, args, caller)
-
+        update(atom, fields, record, args, caller)
       true ->
-        raise ArgumentError,
-              "expected arguments to be a compile time atom or a keyword list, got: " <>
-                Macro.to_string(args)
+        msg = "expected arguments to be a compile time atom or keywords, got: #{Macro.to_string args}"
+        raise ArgumentError, msg
     end
   end
 
   # Gets the index of field.
-  defp index(tag, fields, field) do
+  defp index(atom, fields, field) do
     if index = find_index(fields, field, 0) do
-      # Convert to Elixir index
-      index - 1
+      index - 1 # Convert to Elixir index
     else
-      raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(field)}"
+      raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect field}"
     end
   end
 
   # Creates a new record with the given default fields and keyword values.
-  defp create(tag, fields, keyword, caller) do
+  defp create(atom, fields, keyword, caller) do
     in_match = Macro.Env.in_match?(caller)
     keyword = apply_underscore(fields, keyword)
 
     {match, remaining} =
-      Enum.map_reduce(fields, keyword, fn {field, default}, each_keyword ->
+      Enum.map_reduce(fields, keyword, fn({field, default}, each_keyword) ->
         new_fields =
           case Keyword.fetch(each_keyword, field) do
             {:ok, value} -> value
@@ -372,45 +312,42 @@ defmodule Record do
 
     case remaining do
       [] ->
-        {:{}, [], [tag | match]}
-
-      _ ->
+        {:{}, [], [atom | match]}
+      _  ->
         keys = for {key, _} <- remaining, do: key
-        raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(hd(keys))}"
+        raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect hd(keys)}"
     end
   end
 
   # Updates a record given by var with the given keyword.
-  defp update(tag, fields, var, keyword, caller) do
+  defp update(atom, fields, var, keyword, caller) do
     if Macro.Env.in_match?(caller) do
       raise ArgumentError, "cannot invoke update style macro inside match"
     end
 
     keyword = apply_underscore(fields, keyword)
 
-    Enum.reduce(keyword, var, fn {key, value}, acc ->
+    Enum.reduce keyword, var, fn({key, value}, acc) ->
       index = find_index(fields, key, 0)
-
       if index do
         quote do
           :erlang.setelement(unquote(index), unquote(acc), unquote(value))
         end
       else
-        raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(key)}"
+        raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect key}"
       end
-    end)
+    end
   end
 
   # Gets a record key from the given var.
-  defp get(tag, fields, var, key) do
+  defp get(atom, fields, var, key) do
     index = find_index(fields, key, 0)
-
     if index do
       quote do
         :erlang.element(unquote(index), unquote(var))
       end
     else
-      raise ArgumentError, "record #{inspect(tag)} does not have the key: #{inspect(key)}"
+      raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect key}"
     end
   end
 
@@ -420,32 +357,20 @@ defmodule Record do
 
   # Returns a keyword list of the record
   @doc false
-  def __keyword__(tag, fields, record) do
-    if is_record(record, tag) do
+  def __keyword__(atom, fields, record) do
+    if is_record(record, atom) do
       [_tag | values] = Tuple.to_list(record)
-
-      case join_keyword(fields, values, []) do
-        kv when is_list(kv) ->
-          kv
-
-        expected_fields ->
-          raise ArgumentError,
-                "expected argument to be a #{inspect(tag)} record with " <>
-                  "#{expected_fields} fields, got: " <> inspect(record)
-      end
+      join_keyword(fields, values, [])
     else
-      raise ArgumentError,
-            "expected argument to be a literal atom, literal keyword or " <>
-              "a #{inspect(tag)} record, got runtime: " <> inspect(record)
+      msg = "expected argument to be a literal atom, literal keyword or a #{inspect atom} record, got runtime: #{inspect record}"
+      raise ArgumentError, msg
     end
   end
 
-  # Returns a keyword list, or expected number of fields on size mismatch
   defp join_keyword([{field, _default} | fields], [value | values], acc),
     do: join_keyword(fields, values, [{field, value} | acc])
-
-  defp join_keyword([], [], acc), do: :lists.reverse(acc)
-  defp join_keyword(rest_fields, _rest_values, acc), do: length(acc) + length(rest_fields)
+  defp join_keyword([], [], acc),
+    do: :lists.reverse(acc)
 
   defp apply_underscore(fields, keyword) do
     case Keyword.fetch(keyword, :_) do
@@ -454,7 +379,6 @@ defmodule Record do
         |> Enum.map(fn {k, _} -> {k, default} end)
         |> Keyword.merge(keyword)
         |> Keyword.delete(:_)
-
       :error ->
         keyword
     end

lib/elixir/lib/record/extractor.ex

@@ -1,31 +1,33 @@
 defmodule Record.Extractor do
   @moduledoc false
 
-  def extract(name, opts) do
-    extract_record(name, from_or_from_lib_file(opts))
+  # Retrieve a record definition from an Erlang file using
+  # the same lookup as the *include* attribute from Erlang modules.
+  def extract(name, from: file) when is_binary(file) do
+    extract_record(name, from_file(file))
   end
 
-  def extract_all(opts) do
-    extract_all_records(from_or_from_lib_file(opts))
+  # Retrieve a record definition from an Erlang file using
+  # the same lookup as the *include_lib* attribute from Erlang modules.
+  def extract(name, from_lib: file) when is_binary(file) do
+    extract_record(name, from_lib_file(file))
   end
 
-  defp from_or_from_lib_file(opts) do
-    cond do
-      file = opts[:from] ->
-        {from_file(file), Keyword.delete(opts, :from)}
+  # Retrieve all records definitions from an Erlang file using
+  # the same lookup as the *include* attribute from Erlang modules.
+  def extract_all(from: file) when is_binary(file) do
+    extract_all_records(from_file(file))
+  end
 
-      file = opts[:from_lib] ->
-        {from_lib_file(file), Keyword.delete(opts, :from_lib)}
-
-      true ->
-        raise ArgumentError, "expected :from or :from_lib to be given as option"
-    end
+  # Retrieve all records definitions from an Erlang file using
+  # the same lookup as the *include_lib* attribute from Erlang modules.
+  def extract_all(from_lib: file) when is_binary(file) do
+    extract_all_records(from_lib_file(file))
   end
 
   # Find file using the same lookup as the *include* attribute from Erlang modules.
   defp from_file(file) do
     file = String.to_charlist(file)
-
     case :code.where_is_file(file) do
       :non_existing -> file
       realfile -> realfile
@@ -35,33 +37,28 @@ defmodule Record.Extractor do
   # Find file using the same lookup as the *include_lib* attribute from Erlang modules.
   defp from_lib_file(file) do
     [app | path] = :filename.split(String.to_charlist(file))
-
     case :code.lib_dir(List.to_atom(app)) do
       {:error, _} ->
         raise ArgumentError, "lib file #{file} could not be found"
-
       libpath ->
         :filename.join([libpath | path])
     end
   end
 
   # Retrieve the record with the given name from the given file
-  defp extract_record(name, {file, opts}) do
-    form = read_file(file, opts)
+  defp extract_record(name, file) do
+    form = read_file(file)
     records = extract_records(form)
-
     if record = List.keyfind(records, name, 0) do
       parse_record(record, form)
     else
-      raise ArgumentError,
-            "no record #{name} found at #{file}. Or the record does not exist or " <>
-              "its entry is malformed or depends on other include files"
+      raise ArgumentError, "no record #{name} found at #{file}"
     end
   end
 
   # Retrieve all records from the given file
-  defp extract_all_records({file, opts}) do
-    form = read_file(file, opts)
+  defp extract_all_records(file) do
+    form = read_file(file)
     records = extract_records(form)
     for rec = {name, _fields} <- records, do: {name, parse_record(rec, form)}
   end
@@ -75,11 +72,10 @@ defmodule Record.Extractor do
   # includes record but with macros and other attributes expanded,
   # such as "-include(...)" and "-include_lib(...)". This is done
   # by using Erlang's epp.
-  defp read_file(file, opts) do
-    case :epp.parse_file(file, opts) do
+  defp read_file(file) do
+    case :epp.parse_file(file, []) do
       {:ok, form} ->
         form
-
       other ->
         raise "error parsing file #{file}, got: #{inspect(other)}"
     end
@@ -89,7 +85,9 @@ defmodule Record.Extractor do
   # list of tuples where the first element is the field
   # and the second is its default value.
   defp parse_record({_name, fields}, form) do
-    cons = List.foldr(fields, {nil, 0}, fn f, acc -> {:cons, 0, parse_field(f), acc} end)
+    cons = List.foldr fields, {nil, 0}, fn f, acc ->
+      {:cons, 0, parse_field(f), acc}
+    end
     eval_record(cons, form)
   end
 
@@ -106,10 +104,12 @@ defmodule Record.Extractor do
   end
 
   defp eval_record(cons, form) do
-    form = form ++ [{:function, 0, :hello, 0, [{:clause, 0, [], [], [cons]}]}]
+    form = form ++
+      [{:function, 0, :hello, 0, [
+         {:clause, 0, [], [], [cons]}]}]
 
-    {:function, 0, :hello, 0, [{:clause, 0, [], [], [record_ast]}]} =
-      :erl_expand_records.module(form, []) |> List.last()
+    {:function, 0, :hello, 0, [
+      {:clause, 0, [], [], [record_ast]}]} = :erl_expand_records.module(form, []) |> List.last
 
     {:value, record, _} = :erl_eval.expr(record_ast, [])
     record

lib/elixir/lib/regex.ex

@@ -1,50 +1,23 @@
 defmodule Regex do
   @moduledoc ~S"""
-  Provides regular expressions for Elixir.
+  Provides regular expressions for Elixir. Built on top of Erlang's `:re`
+  module.
 
-  Regex is based on PCRE (Perl Compatible Regular Expressions) and
-  built on top of Erlang's `:re` module. More information can be found
-  in the [`:re` module documentation](http://www.erlang.org/doc/man/re.html).
+  As the `:re` module, Regex is based on PCRE
+  (Perl Compatible Regular Expressions). More information can be
+  found in the [`:re` module documentation](http://www.erlang.org/doc/man/re.html).
 
-  Regular expressions in Elixir can be created using the sigils
-  [`~r`](`Kernel.sigil_r/2`) or [`~R`](`Kernel.sigil_R/2`):
+  Regular expressions in Elixir can be created using `Regex.compile!/2`
+  or using the special form with [`~r`](Kernel.html#sigil_r/2) or [`~R`](Kernel.html#sigil_R/2):
 
-      # A simple regular expression that matches foo anywhere in the string
+      # A simple regular expressions that matches foo anywhere in the string
       ~r/foo/
 
       # A regular expression with case insensitive and Unicode options
       ~r/foo/iu
 
-  Regular expressions created via sigils are pre-compiled and stored
-  in the `.beam` file. Notice this may be a problem if you are precompiling
-  Elixir, see the "Precompilation" section for more information.
-
   A Regex is represented internally as the `Regex` struct. Therefore,
   `%Regex{}` can be used whenever there is a need to match on them.
-  Keep in mind it is not guaranteed two regular expressions from the
-  same source are equal, for example:
-
-      ~r/(?<foo>.)(?<bar>.)/ == ~r/(?<foo>.)(?<bar>.)/
-
-  may return `true` or `false` depending on your machine, endianness,
-  available optimizations and others. You can, however, retrieve the source
-  of a compiled regular expression by accessing the `source` field, and then
-  compare those directly:
-
-      ~r/(?<foo>.)(?<bar>.)/.source == ~r/(?<foo>.)(?<bar>.)/.source
-
-  ## Precompilation
-
-  Regular expressions built with sigil are precompiled and stored in `.beam`
-  files. This may be a problem if you are precompiling Elixir to run in
-  different OTP releases, as OTP releases may update the underlying regular
-  expression engine at any time.
-
-  For such reasons, we always recommend precompiling Elixir projects using
-  the Erlang/OTP version meant to run in production. In case cross-compilation is
-  really necessary, you can manually invoke `Regex.recompile/1` or
-  `Regex.recompile!/1` to perform a runtime version check and recompile the
-  regex if necessary.
 
   ## Modifiers
 
@@ -54,7 +27,7 @@ defmodule Regex do
       modifiers like `\w`, `\W`, `\s` and friends to also match on Unicode.
       It expects valid Unicode strings to be given on match
 
-    * `caseless` (i) - adds case insensitivity
+    * `caseless` (i) - add case insensitivity
 
     * `dotall` (s) - causes dot to match newlines and also set newline to
       anycrlf; the new line setting can be overridden by setting `(*CR)` or
@@ -93,11 +66,11 @@ defmodule Regex do
       complete matching part of the string; all explicitly captured subpatterns
       are discarded
 
-    * `:all_but_first` - all but the first matching subpattern, i.e. all
+    * `:all_but_first`- all but the first matching subpattern, i.e. all
       explicitly captured subpatterns, but not the complete matching part of
       the string
 
-    * `:none` - does not return matching subpatterns at all
+    * `:none` - do not return matching subpatterns at all
 
     * `:all_names` - captures all names in the Regex
 
@@ -105,7 +78,7 @@ defmodule Regex do
 
   """
 
-  defstruct re_pattern: nil, source: "", opts: "", re_version: ""
+  defstruct re_pattern: nil, source: "", opts: ""
 
   @type t :: %__MODULE__{re_pattern: term, source: binary, opts: binary}
 
@@ -117,9 +90,8 @@ defmodule Regex do
   Compiles the regular expression.
 
   The given options can either be a binary with the characters
-  representing the same regex options given to the
-  [`~r`](`Kernel.sigil_r/2`) sigil, or a list of options, as
-  expected by the Erlang's `:re` module.
+  representing the same regex options given to the `~r` sigil,
+  or a list of options, as expected by the Erlang's [`:re` module](http://www.erlang.org/doc/man/re.html).
 
   It returns `{:ok, regex}` in case of success,
   `{:error, reason}` otherwise.
@@ -127,96 +99,47 @@ defmodule Regex do
   ## Examples
 
       iex> Regex.compile("foo")
-      {:ok, ~r/foo/}
+      {:ok, ~r"foo"}
 
       iex> Regex.compile("*foo")
       {:error, {'nothing to repeat', 0}}
 
   """
   @spec compile(binary, binary | [term]) :: {:ok, t} | {:error, any}
-  def compile(source, options \\ "") do
-    compile(source, options, version())
-  end
+  def compile(source, options \\ "")
 
-  defp compile(source, options, version) when is_binary(options) do
+  def compile(source, options) when is_binary(options) do
     case translate_options(options, []) do
       {:error, rest} ->
         {:error, {:invalid_option, rest}}
 
       translated_options ->
-        compile(source, translated_options, options, version)
+        compile(source, translated_options, options)
     end
   end
 
-  defp compile(source, options, version) when is_list(options) do
-    compile(source, options, "", version)
+  def compile(source, options) when is_list(options) do
+    compile(source, options, "")
   end
 
-  defp compile(source, opts, doc_opts, version) when is_binary(source) do
+  defp compile(source, opts, doc_opts) when is_binary(source) do
     case :re.compile(source, opts) do
       {:ok, re_pattern} ->
-        {:ok, %Regex{re_pattern: re_pattern, re_version: version, source: source, opts: doc_opts}}
-
+        {:ok, %Regex{re_pattern: re_pattern, source: source, opts: doc_opts}}
       error ->
         error
     end
   end
 
   @doc """
-  Compiles the regular expression and raises `Regex.CompileError` in case of errors.
+  Compiles the regular expression according to the given options.
+  Fails with `Regex.CompileError` if the regex cannot be compiled.
   """
   @spec compile!(binary, binary | [term]) :: t
   def compile!(source, options \\ "") do
     case compile(source, options) do
       {:ok, regex} -> regex
-      {:error, {reason, at}} -> raise Regex.CompileError, "#{reason} at position #{at}"
-    end
-  end
-
-  @doc """
-  Recompiles the existing regular expression if necessary.
-
-  This checks the version stored in the regular expression
-  and recompiles the regex in case of version mismatch.
-  """
-  @doc since: "1.4.0"
-  @spec recompile(t) :: t
-  def recompile(%Regex{} = regex) do
-    version = version()
-
-    case regex do
-      %{re_version: ^version} ->
-        {:ok, regex}
-
-      _ ->
-        %{source: source, opts: opts} = regex
-        compile(source, opts, version)
-    end
-  end
-
-  @doc """
-  Recompiles the existing regular expression and raises `Regex.CompileError` in case of errors.
-  """
-  @doc since: "1.4.0"
-  @spec recompile!(t) :: t
-  def recompile!(regex) do
-    case recompile(regex) do
-      {:ok, regex} -> regex
-      {:error, {reason, at}} -> raise Regex.CompileError, "#{reason} at position #{at}"
-    end
-  end
-
-  @doc """
-  Returns the version of the underlying Regex engine.
-  """
-  @doc since: "1.4.0"
-  @spec version :: term()
-  # TODO: No longer check for function_exported? on OTP 20+.
-  def version do
-    if function_exported?(:re, :version, 0) do
-      {:re.version(), :erlang.system_info(:endian)}
-    else
-      {"8.33 2013-05-29", :erlang.system_info(:endian)}
+      {:error, {reason, at}} -> raise Regex.CompileError, message: "#{reason} at position #{at}"
     end
   end
 
@@ -232,7 +155,7 @@ defmodule Regex do
       false
 
   """
-  @spec match?(t, String.t()) :: boolean
+  @spec match?(t, String.t) :: boolean
   def match?(%Regex{re_pattern: compiled}, string) when is_binary(string) do
     :re.run(string, compiled, [{:capture, :none}]) == :match
   end
@@ -261,8 +184,7 @@ defmodule Regex do
 
   ## Options
 
-    * `:return` - set to `:index` to return byte index and match length.
-      Defaults to `:binary`.
+    * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
     * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
       to see the possible capture values.
 
@@ -282,23 +204,20 @@ defmodule Regex do
   def run(regex, string, options \\ [])
 
   def run(%Regex{re_pattern: compiled}, string, options) when is_binary(string) do
-    return = Keyword.get(options, :return, :binary)
+    return   = Keyword.get(options, :return, :binary)
     captures = Keyword.get(options, :capture, :all)
 
     case :re.run(string, compiled, [{:capture, captures, return}]) do
       :nomatch -> nil
-      :match -> []
+      :match   -> []
       {:match, results} -> results
     end
   end
 
   @doc """
-  Returns the given captures as a map or `nil` if no captures are found.
-
-  ## Options
-
-    * `:return` - set to `:index` to return byte index and match length.
-      Defaults to `:binary`.
+  Returns the given captures as a map or `nil` if no captures are
+  found. The option `:return` can be set to `:index` to get indexes
+  back.
 
   ## Examples
 
@@ -312,7 +231,7 @@ defmodule Regex do
       nil
 
   """
-  @spec named_captures(t, String.t(), [term]) :: map | nil
+  @spec named_captures(t, String.t, [term]) :: map | nil
   def named_captures(regex, string, options \\ []) when is_binary(string) do
     names = names(regex)
     options = Keyword.put(options, :capture, names)
@@ -337,7 +256,7 @@ defmodule Regex do
       "foo"
 
   """
-  @spec source(t) :: String.t()
+  @spec source(t) :: String.t
   def source(%Regex{source: source}) do
     source
   end
@@ -351,7 +270,7 @@ defmodule Regex do
       "m"
 
   """
-  @spec opts(t) :: String.t()
+  @spec opts(t) :: String.t
   def opts(%Regex{opts: opts}) do
     opts
   end
@@ -365,13 +284,13 @@ defmodule Regex do
       ["foo"]
 
   """
-  @spec names(t) :: [String.t()]
+  @spec names(t) :: [String.t]
   def names(%Regex{re_pattern: re_pattern}) do
     {:namelist, names} = :re.inspect(re_pattern, :namelist)
     names
   end
 
-  @doc ~S"""
+  @doc """
   Same as `run/3`, but scans the target several times collecting all
   matches of the regular expression.
 
@@ -380,8 +299,7 @@ defmodule Regex do
 
   ## Options
 
-    * `:return` - set to `:index` to return byte index and match length.
-      Defaults to `:binary`.
+    * `:return`  - set to `:index` to return indexes. Defaults to `:binary`.
     * `:capture` - what to capture in the result. Check the moduledoc for `Regex`
       to see the possible capture values.
 
@@ -396,20 +314,14 @@ defmodule Regex do
       iex> Regex.scan(~r/e/, "abcd")
       []
 
-      iex> Regex.scan(~r/\p{Sc}/u, "$, £, and €")
-      [["$"], ["£"], ["€"]]
-
-      iex> Regex.scan(~r/=+/, "=ü†ƒ8===", return: :index)
-      [[{0, 1}], [{9, 3}]]
-
   """
-  @spec scan(t, String.t(), [term]) :: [[String.t()]]
+  @spec scan(t, String.t, [term]) :: [[String.t]]
   def scan(regex, string, options \\ [])
 
   def scan(%Regex{re_pattern: compiled}, string, options) when is_binary(string) do
-    return = Keyword.get(options, :return, :binary)
+    return   = Keyword.get(options, :return, :binary)
     captures = Keyword.get(options, :capture, :all)
-    options = [{:capture, captures, return}, :global]
+    options  = [{:capture, captures, return}, :global]
 
     case :re.run(string, compiled, options) do
       :match -> []
@@ -430,7 +342,6 @@ defmodule Regex do
       given pattern.
 
     * `:trim` - when `true`, removes empty strings (`""`) from the result.
-      Defaults to `false`.
 
     * `:on` - specifies which captures to split the string on, and in what
       order. Defaults to `:first` which means captures inside the regex do not
@@ -441,32 +352,32 @@ defmodule Regex do
 
   ## Examples
 
-      iex> Regex.split(~r{-}, "a-b-c")
+      iex> Regex.split(~r/-/, "a-b-c")
       ["a", "b", "c"]
 
-      iex> Regex.split(~r{-}, "a-b-c", parts: 2)
+      iex> Regex.split(~r/-/, "a-b-c", [parts: 2])
       ["a", "b-c"]
 
-      iex> Regex.split(~r{-}, "abc")
+      iex> Regex.split(~r/-/, "abc")
       ["abc"]
 
-      iex> Regex.split(~r{}, "abc")
-      ["", "a", "b", "c", ""]
+      iex> Regex.split(~r//, "abc")
+      ["a", "b", "c", ""]
 
-      iex> Regex.split(~r{a(?<second>b)c}, "abc")
+      iex> Regex.split(~r/a(?<second>b)c/, "abc")
       ["", ""]
 
-      iex> Regex.split(~r{a(?<second>b)c}, "abc", on: [:second])
+      iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second])
       ["a", "c"]
 
-      iex> Regex.split(~r{(x)}, "Elixir", include_captures: true)
+      iex> Regex.split(~r/(x)/, "Elixir", include_captures: true)
       ["Eli", "x", "ir"]
 
-      iex> Regex.split(~r{a(?<second>b)c}, "abc", on: [:second], include_captures: true)
+      iex> Regex.split(~r/a(?<second>b)c/, "abc", on: [:second], include_captures: true)
       ["a", "b", "c"]
 
   """
-  @spec split(t, String.t(), [term]) :: [String.t()]
+  @spec split(t, String.t, [term]) :: [String.t]
   def split(regex, string, options \\ [])
 
   def split(%Regex{}, "", opts) do
@@ -477,32 +388,26 @@ defmodule Regex do
     end
   end
 
-  def split(%Regex{re_pattern: compiled}, string, opts)
-      when is_binary(string) and is_list(opts) do
+  def split(%Regex{re_pattern: compiled}, string, opts) when is_binary(string) and is_list(opts) do
     on = Keyword.get(opts, :on, :first)
-
     case :re.run(string, compiled, [:global, capture: on]) do
       {:match, matches} ->
-        index = parts_to_index(Keyword.get(opts, :parts, :infinity))
-        trim = Keyword.get(opts, :trim, false)
-        include_captures = Keyword.get(opts, :include_captures, false)
-        do_split(matches, string, 0, index, trim, include_captures)
-
+        do_split(matches, string, 0,
+                 parts_to_index(Keyword.get(opts, :parts, :infinity)),
+                 Keyword.get(opts, :trim, false),
+                 Keyword.get(opts, :include_captures, false))
       :match ->
         [string]
-
       :nomatch ->
         [string]
     end
   end
 
-  defp parts_to_index(:infinity), do: 0
+  defp parts_to_index(:infinity),                      do: 0
   defp parts_to_index(n) when is_integer(n) and n > 0, do: n
 
-  defp do_split(_, string, offset, _counter, true, _with_captures)
-       when byte_size(string) <= offset do
-    []
-  end
+  defp do_split(_, string, offset, _counter, true, _with_captures) when byte_size(string) <= offset,
+    do: []
 
   defp do_split(_, string, offset, 1, _trim, _with_captures),
     do: [binary_part(string, offset, byte_size(string) - offset)]
@@ -510,10 +415,8 @@ defmodule Regex do
   defp do_split([], string, offset, _counter, _trim, _with_captures),
     do: [binary_part(string, offset, byte_size(string) - offset)]
 
-  defp do_split([[{pos, _} | h] | t], string, offset, counter, trim, with_captures)
-       when pos - offset < 0 do
-    do_split([h | t], string, offset, counter, trim, with_captures)
-  end
+  defp do_split([[{pos, _} | h] | t], string, offset, counter, trim, with_captures) when pos - offset < 0,
+    do: do_split([h | t], string, offset, counter, trim, with_captures)
 
   defp do_split([[] | t], string, offset, counter, trim, with_captures),
     do: do_split(t, string, offset, counter, trim, with_captures)
@@ -522,13 +425,16 @@ defmodule Regex do
     new_offset = pos + length
     keep = pos - offset
 
-    <<_::binary-size(offset), part::binary-size(keep), match::binary-size(length), _::binary>> =
-      string
-
-    if keep == 0 and trim do
-      [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+    if keep == 0 and length == 0 do
+      do_split([h | t], string, new_offset, counter, trim, true)
     else
-      [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+      <<_::binary-size(offset), part::binary-size(keep), match::binary-size(length), _::binary>> = string
+
+      if keep == 0 and (length == 0 or trim) do
+        [match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+      else
+        [part, match | do_split([h | t], string, new_offset, counter - 1, trim, true)]
+      end
     end
   end
 
@@ -536,7 +442,7 @@ defmodule Regex do
     new_offset = pos + length
     keep = pos - offset
 
-    if keep == 0 and trim do
+    if keep == 0 and (length == 0 or trim) do
       do_split([h | t], string, new_offset, counter, trim, false)
     else
       <<_::binary-size(offset), part::binary-size(keep), _::binary>> = string
@@ -550,10 +456,8 @@ defmodule Regex do
 
   The replacement can be either a string or a function. The string
   is used as a replacement for every match and it allows specific
-  captures to be accessed via `\N` or `\g{N}`, where `N` is the
-  capture. In case `\0` is used, the whole match is inserted. Note
-  that in regexes the backslash needs to be escaped, hence in practice
-  you'll need to use `\\N` and `\\g{N}`.
+  captures to be accessed via `\\N` or `\g{N}`, where `N` is the
+  capture. In case `\\0` is used, the whole match is inserted.
 
   When the replacement is a function, the function may have arity
   N where each argument maps to a capture, with the first argument
@@ -589,7 +493,7 @@ defmodule Regex do
       "Abcadc"
 
   """
-  @spec replace(t, String.t(), String.t() | (... -> String.t()), [term]) :: String.t()
+  @spec replace(t, String.t, String.t | (... -> String.t), [term]) :: String.t
   def replace(regex, string, replacement, options \\ [])
 
   def replace(regex, string, replacement, options)
@@ -598,8 +502,8 @@ defmodule Regex do
   end
 
   def replace(regex, string, replacement, options)
-      when is_binary(string) and is_function(replacement) and is_list(options) do
-    {:arity, arity} = Function.info(replacement, :arity)
+      when is_binary(string) and is_function(replacement) and is_list(options)  do
+    {:arity, arity} = :erlang.fun_info(replacement, :arity)
     do_replace(regex, string, {replacement, arity}, options)
   end
 
@@ -610,16 +514,15 @@ defmodule Regex do
     case :re.run(string, compiled, opts) do
       :nomatch ->
         string
-
       {:match, [mlist | t]} when is_list(mlist) ->
-        apply_list(string, replacement, [mlist | t]) |> IO.iodata_to_binary()
-
+        apply_list(string, replacement, [mlist | t]) |> IO.iodata_to_binary
       {:match, slist} ->
-        apply_list(string, replacement, [slist]) |> IO.iodata_to_binary()
+        apply_list(string, replacement, [slist]) |> IO.iodata_to_binary
     end
   end
 
-  defp precompile_replacement(""), do: []
+  defp precompile_replacement(""),
+    do: []
 
   defp precompile_replacement(<<?\\, ?g, ?{, rest::binary>>) when byte_size(rest) > 0 do
     {ns, <<?}, rest::binary>>} = pick_int(rest)
@@ -639,7 +542,6 @@ defmodule Regex do
     case precompile_replacement(rest) do
       [head | t] when is_binary(head) ->
         [<<x, head::binary>> | t]
-
       other ->
         [<<x>> | other]
     end
@@ -666,8 +568,7 @@ defmodule Regex do
     string
   end
 
-  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list)
-       when mpos > pos do
+  defp apply_list(whole, string, pos, replacement, [[{mpos, _} | _] | _] = list) when mpos > pos do
     length = mpos - pos
     <<untouched::binary-size(length), rest::binary>> = string
     [untouched | apply_list(whole, rest, mpos, replacement, list)]
@@ -694,10 +595,8 @@ defmodule Regex do
       cond do
         is_binary(part) ->
           part
-
         part >= tuple_size(indexes) ->
           ""
-
         true ->
           get_index(string, elem(indexes, part))
       end
@@ -725,6 +624,9 @@ defmodule Regex do
     [get_index(string, h) | get_indexes(string, t, arity - 1)]
   end
 
+  {:ok, pattern} = :re.compile(~S"[.^$*+?()\[\]{}\\\|\s#]", [:unicode])
+  @escape_pattern pattern
+
   @doc ~S"""
   Escapes a string to be literally matched in a regex.
 
@@ -737,33 +639,9 @@ defmodule Regex do
       "\\\\what\\ if"
 
   """
-  @spec escape(String.t()) :: String.t()
+  @spec escape(String.t) :: String.t
   def escape(string) when is_binary(string) do
-    string
-    |> escape(_length = 0, string)
-    |> IO.iodata_to_binary()
-  end
-
-  @escapable '.^$*+?()[]{}|#-\\\t\n\v\f\r\s'
-
-  defp escape(<<char, rest::binary>>, length, original) when char in @escapable do
-    escape_char(rest, length, original, char)
-  end
-
-  defp escape(<<_, rest::binary>>, length, original) do
-    escape(rest, length + 1, original)
-  end
-
-  defp escape(<<>>, _length, original) do
-    original
-  end
-
-  defp escape_char(<<rest::binary>>, 0, _original, char) do
-    [?\\, char | escape(rest, 0, rest)]
-  end
-
-  defp escape_char(<<rest::binary>>, length, original, char) do
-    [binary_part(original, 0, length), ?\\, char | escape(rest, 0, rest)]
+    :re.replace(string, @escape_pattern, "\\\\&", [:global, {:return, :binary}])
   end
 
   # Helpers
@@ -776,7 +654,7 @@ defmodule Regex do
   def unescape_map(?t), do: ?\t
   def unescape_map(?v), do: ?\v
   def unescape_map(?a), do: ?\a
-  def unescape_map(_), do: false
+  def unescape_map(_),  do: false
 
   # Private Helpers
 
@@ -785,15 +663,12 @@ defmodule Regex do
   defp translate_options(<<?x, t::binary>>, acc), do: translate_options(t, [:extended | acc])
   defp translate_options(<<?f, t::binary>>, acc), do: translate_options(t, [:firstline | acc])
   defp translate_options(<<?U, t::binary>>, acc), do: translate_options(t, [:ungreedy | acc])
-
-  defp translate_options(<<?s, t::binary>>, acc),
-    do: translate_options(t, [:dotall, {:newline, :anycrlf} | acc])
-
+  defp translate_options(<<?s, t::binary>>, acc), do: translate_options(t, [:dotall, {:newline, :anycrlf} | acc])
   defp translate_options(<<?m, t::binary>>, acc), do: translate_options(t, [:multiline | acc])
 
   # TODO: Remove on 2.0
   defp translate_options(<<?r, t::binary>>, acc) do
-    IO.warn("the /r modifier in regular expressions is deprecated, please use /U instead")
+    IO.warn "the /r modifier in regular expressions is deprecated, please use /U instead"
     translate_options(t, [:ungreedy | acc])
   end