Update CHANGELOG.md

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

.appveyor.yml

@@ -1,9 +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

.gitignore

@@ -1,14 +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/src/elixir.app.src
-/lib/elixir/test/ebin/
+/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,38 +1,14 @@
 language: erlang
+
+otp_release:
+  - 18.0
+
 sudo: false
 
-os: linux
-otp_release: 18.0
-
-matrix:
-  include:
-    - os: linux
-      otp_release: 18.1
-    - os: linux
-      otp_release: 18.2
-    - os: linux
-      otp_release: 18.3
-    - os: linux
-      otp_release: 19.0
-    - os: linux
-      otp_release: 19.1
-    - os: linux
-      otp_release: 19.2
-    - os: linux
-      otp_release: 19.3
-    - os: linux
-      otp_release: 20.0
-
-env:
-  - ELIXIR_ASSERT_TIMEOUT=2000
-
-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@plataformatec.com.br
     - eric.meadows.jonsson@gmail.com

CHANGELOG.md

@@ -1,402 +1,282 @@
-# Changelog for Elixir v1.5
+# Changelog for Elixir v1.2
 
-Elixir v1.5 brings new features, enhancements and bug fixes to Elixir. It is the first release to leverage features added as part of Erlang/OTP 20. It is also the last release that supports Erlang/OTP 18.
+v1.2 brings enhancements, bug fixes, performance improvements and more
+into Elixir. Elixir v1.2 relies on many features in Erlang 18, requiring
+at least Erlang 18+. Upgrading to Erlang 18 is therefore necessary before
+upgrading Elixir.
 
-## UTF-8 atoms, function names and variables
+## Erlang 18 support
 
-Elixir v1.5 supports non-quoted atoms and variables to be in UTF-8 when using Erlang/OTP 20+. For example:
+We have brought many features specific to Erlang 18. Here are the highlights:
 
-    test "こんにちは世界" do
-      assert :こんにちは世界
-    end
+  * Maps can now scale from dozens to millions of keys. Therefore, usage of
+    the modules `Dict` and `HashDict` is now discouraged and will be
+    deprecated in future releases, instead use `Map`. Similarly, `Set` and
+    `HashSet` will be deprecated in favor of `MapSet`
+  * Compilation times are faster due to improvements in both the Elixir and
+    Erlang compilers
+  * Dialyzer now emits less false negative warnings thanks to new annotations
+    available in the Erlang compiler
 
-Or:
+## Language improvements
 
-    saudação = "Bom dia!"
+This release includes four notable language improvements:
 
-Elixir follows the recommendations in [Unicode Annex #31](http://unicode.org/reports/tr31/) to make the language more accessible to other languages and communities. Identifiers must start with a letter or underscore, optionally followed by letters, digits, and underscores. Here letter means any UTF-8 letter-character (optionally with a combining mark) and digit means a UTF-8 decimal-digit-character. If you're using ASCII, this does what you'd expect.
+  * The addition of multi aliases/imports/require:
 
-Examples of valid variables are:
+        alias MyApp.{Foo, Bar, Baz}
 
-    name    josé   _age   まつもと  _42  адрес
-    
-Examples of invalid variables include:
+  * Support for variables in map keys:
 
-    name•   a±2  42
+        %{key => value}
 
-Symbols, such as mathematical notations and emoji, are not allowed identifiers.
+  * Support for the pin operator in map keys and function clauses:
 
-For a complete reference on Elixir syntax, see the [Syntax Reference](https://hexdocs.pm/elixir/syntax-reference.html). For technical details on Unicode support, see [Unicode Syntax](https://hexdocs.pm/elixir/unicode-syntax.html).
+        %{^key => value} = %{key => value}
+        fn ^key -> :ok end
 
-## IEx improvements
+  * Addition of the `with` special form to match on multiple expressions:
 
-IEx got many improvements. The autocompletion system is now capable of autocompleting variables and user imports. New helpers have also been added:
+        with {:ok, contents} <- File.read("my_file.ex"),
+             {res, binding} <- Code.eval_string(contents),
+             do: {:ok, res}
 
-  * `exports/1` lists all exports (functions and macros) in a given module
-  * `open/1` opens up the source of a module or function directly in your editor. For example, `open MyApp.Module`
-  * `runtime_info/0` prints general information about the running system, such as number of cores, runtime version, allocation of memory in the VM and more
+These improvements aim to make the language more consistent and expressive.
 
-IEx also features a breakpoint system for code debugging. The following functions have been added to aid debugging:
+## Getting started experience
 
-  * `break!/2` - sets up a breakpoint for a given `Mod.fun/arity`
-  * `break!/4` - sets up a breakpoint for the given module, function, arity
-  * `breaks/0` - prints all breakpoints and their ids
-  * `continue/0` - continues until the next breakpoint in the same process
-  * `open/0` - opens editor on the current breakpoint
-  * `remove_breaks/0` - removes all breakpoints in all modules
-  * `remove_breaks/1` - removes all breakpoints in a given module
-  * `reset_break/1` - sets the number of stops on the given id to zero
-  * `reset_break/3` - sets the number of stops on the given module, function, arity to zer
-  * `respawn/0` - starts a new shell (breakpoints will ask for permission once more)
-  * `whereami/1` - shows the current location
+While we were improving the language, we also improved both the parser and
+compiler to be even more aware of language constructs, emitting warnings
+on common pitfalls like when piping to expressions without parentheses or
+when defining unsafe variables.
 
-## Exception.blame
+We have also introduced the `i/1` helper in IEx, which allows developers
+to retrieve information about any data type. This will help newcomers
+explore the language values while providing experienced developers with
+crucial information about the value they are introspecting.
 
-`Exception.blame/3` is a new function in Elixir that is capable of attaching debug information to certain exceptions. Currently this is used to augment `FunctionClauseError`s with a summary of all clauses and which parts of clause match and which ones didn't. For example:
+## Workflow improvements
 
-    iex> Access.fetch(:foo, :bar)
-    ** (FunctionClauseError) no function clause matching in Access.fetch/2
+Umbrella applications are now able to share both build and configuration files.
+This aims to drastically reduce compilation times in umbrella projects by
+adding the following configuration to each umbrella app's `mix.exs` file:
 
-    The following arguments were given to Access.fetch/2:
+    build_path: "../../_build",
+    config_path: "../../config/config.exs",
 
-        # 1
-        :foo
+Finally, Mix will now consolidate protocols by default as we are now able to
+consolidate in parallel and cache the consolidation results, providing the
+best performance across all environments without affecting compilation times.
+The only downside of this change is that, if you have been implementing
+protocols exclusively as part of your test suite, inside the `test` directory,
+those won't be picked up as it happens after compilation. For such cases,
+consolidation can be disabled by setting `consolidate_protocols: false` in
+the project config.
 
-        # 2
-        :bar
+These are great additions on top of the faster compilation times we have
+achieved when migrating to Erlang 18.
 
-    Attempted function clauses (showing 5 out of 5):
+## Rebar 3 support
 
-        def fetch(-%struct{} = container-, key)
-        def fetch(map, key) when -is_map(map)-
-        def fetch(list, key) when -is_list(list)- and is_atom(key)
-        def fetch(list, key) when -is_list(list)-
-        def fetch(-nil-, _key)
+With Rebar 3 gaining more adoption in the Erlang community, Mix is
+now able to fetch and compile Rebar 3 dependencies. This feature is currently
+experimental and therefore opt-in: if you have a Rebar 3 dependency, you can
+ask Mix to use Rebar 3 to compile it by passing the `manager: :rebar3` option.
+Once configured, Mix will prompt you to install Rebar 3 if it is not yet
+available.
 
-    (elixir) lib/access.ex:261: Access.fetch/2
+## v1.2.6 (2016-06-06)
 
-In the example above, an argument that did not match or guard that did not evaluate to true are shown between `-`. If the terminal supports ANSI coloring, they are wrapped in red instead of the `-` character.
+### 1. Enhancements
 
-Since blaming an exception can be expensive, `Exception.blame/3` must be used exclusively in debugging situations. It is not advised to apply it to production components such as a Logger. This feature has been integrated into the compiler, the command line, ExUnit and IEx.
+  * [Kernel] Support Erlang 19
+  * [Kernel] Supported generated: true in the `quote` special form
 
-This feature also requires Erlang/OTP 20+.
+### 2. Bug fixes
 
-## Streamlined child specs
+  * [Path] Fix a bug in path join with "/" followed by empty segments
+  * [String] Fix a bug in NFD normalization when followed by one-byte sized graphemes
+  * [Typespec] Correctly support `<<_::size, _::_*unit>>` syntax
 
-Elixir v1.5 streamlines how supervisors are defined and used in Elixir. Elixir now allows child specifications, which specify how a child process is supervised, to be defined in modules. In previous versions, a project using Phoenix would write:
-
-    import Supervisor.Spec
-
-    children = [
-      supervisor(MyApp.Repo, []),
-      supervisor(MyApp.Endpoint, [])
-    ]
-
-    Supervisor.start_link(children, strategy: :one_for_one)
-
-In Elixir v1.5, one might do:
-
-    children = [
-      MyApp.Repo,
-      MyApp.Endpoint
-    ]
-
-    Supervisor.start_link(children, strategy: :one_for_one)
-
-The above works by calling the `child_spec/1` function on the given modules.
-
-This new approach allows `MyApp.Repo` and `MyApp.Endpoint` to control how they run under a supervisor. This reduces the chances of mistakes being made, such as starting an Ecto repository as a worker or forgetting to declare that tasks are temporary in a supervision tree.
-
-If it is necessary to configure any of the children, such can be done by passing a tuple instead of an atom:
-
-    children = [
-      {MyApp.Repo, url: "ecto://localhost:4567/my_dev"},
-      MyApp.Endpoint
-    ]
-
-The modules `Agent`, `Registry`, `Task`, and `Task.Supervisor` have been updated to include a `child_spec/1` function, allowing them to be used directly in a supervision tree similar to the examples above. `use Agent`, `use GenServer`, `use Supervisor`, and `use Task` have also been updated to automatically define an overridable `child_spec/1` function.
-
-Finally, child specifications are now provided as maps (data-structures) instead of the previous `Supervisor.Spec.worker/3` and `Supervisor.Spec.supervisor/3` APIs. This behaviour also aligns with how supervisors are configured in Erlang/OTP 18+. See the updated `Supervisor` docs for more information, as well as the new `Supervisor.init/2` and `Supervisor.child_spec/2` functions.
-
-## @impl
-
-This release also allows developers to mark which functions in a given module are an implementation of a callback. For example, when using the [Plug](https://github.com/elixir-lang/plug) project, one needs to implement both `init/1` and `call/2` when writing a Plug:
-
-    defmodule MyApp do
-      @behaviour Plug
-
-      def init(_opts) do
-        opts
-      end
-
-      def call(conn, _opts) do
-        Plug.Conn.send_resp(conn, 200, "hello world")
-      end
-    end
-
-The problem with the approach above is that, once more and more functions are added to the `MyApp` module, it becomes increasingly harder to know the purposes of the `init/1` and `call/2` functions. For example, for a developer unfamiliar with Plug, are those functions part of the `MyApp` API or are they implementations of a given callback?
-
-Elixir v1.5 introduces the `@impl` attribute, which allows us to mark that certain functions are implementation of callbacks:
-
-    defmodule MyApp do
-      @behaviour Plug
-
-      @impl true
-      def init(_opts) do
-        opts
-      end
-
-      @impl true
-      def call(conn, _opts) do
-        Plug.Conn.send_resp(conn, 200, "hello world")
-      end
-    end
-
-You may even use `@impl Plug` if you want to explicitly document which behaviour defines the callback you are implementing.
-
-Overall, using `@impl` has the following advantages:
-
-  * Readability of the code is increased, as it is now clear which functions are part of your API and which ones are callback implementations. To reinforce this idea, `@impl true` automatically marks the function as `@doc false`, disabling documentation unless `@doc` is explicitly set
-
-  * If you define `@impl` before a function that is not a callback, Elixir will error. This is useful in case of typos or in case the behaviour definition changes (such as a new major version of a library you depend on is released)
-
-  * If you use `@impl` in one implementation, Elixir will force you to declare `@impl` for all other implementations in the same module, keeping your modules consistent
-
-## Calendar improvements
-
-This release brings further improvements to Calendar types. It adds arithmetic and others functions to `Time`, `Date`, `NaiveDateTime` and `Datetime` as well as conversion between different calendars.
-
-## v1.5.3 (2017-12-19)
+## v1.2.5 (2016-04-30)
 
 ### 1. Bug fixes
 
-#### Elixir
+  * [Logger] Stringify truncated function data in Logger
+  * [Logger] Ensure poorly formatted char data can also be logged by using the replacement character "�" (diamond question mark)
+  * [Mix] Do not assume `@impl` is always a list
+  * [String] Fix bugs in `String.replace_*` functions where it would not include the accumulated value for certain replacements
 
-  * [Calendar] Consider microseconds in maximum possible Calendar.ISO datetime
-  * [Enum] Fix `chunk_every/4` when `step > count`
-  * [Kernel] Warn duplicate definitions in macros
-  * [Kernel] Remove dialyzer warnings from else in with clauses
-  * [Kernel] Do not warning on upcoming `@deprecated` and `@since` attributes for v1.6
-  * [MapSet] Return valid MapSet when union-ing a legacy MapSet
-
-#### ExUnit
-
-  * [ExUnit] Fix compiler warnings in `assert_receive/3`
-
-## v1.5.2 (2017-09-29)
-
-### 1. Enhacements
-
-#### Elixir
-
-  * [Kernel] Optimize function definition with multiple clauses by not traversing the internal clauses table
-  * [Kernel] Warn if unary operators are followed by new lines
-  * [Registry] Use the name of the Registry as its `:id` in the `child_spec/1` function
-
-### 2. Bug fixes
-
-#### Elixir
-
-  * [DateTime] Fix negative microsecond result when passing negative Unix epochs to `from_unix/2`
-  * [Kernel] Improve error message for oversized atoms
-  * [Kernel] Ensure `@impl` attribute also propagates to clauses from default arguments
-  * [Kernel] Emit proper error for unknown vars inside binary pattern in match
-
-#### IEx
-
-  * [IEx] Do not crash IEx unexpectedly on `System.stop/0`
-  * [IEx.Helpers] Ensure exiting a breakpoint set inside a breakpoint does not terminate the shell unexpectedly
-
-#### Mix
-
-  * [mix local.hex] Ensure `--if-missing` flag works as advertised
-  * [mix test] Do not trigger additional error reports when there is a failure when loading test files
-  * [Mix.SCM.Git] Ensure errors when invoking `git` propagate correctly
-
-## v1.5.1 (2017-08-01)
+## v1.2.4 (2016-04-01)
 
 ### 1. Enhancements
 
-#### EEx
-
-  * [EEx.Engine] Add `handle_begin` and `handle_end` to EEx
-
-#### Elixir
-
-  * [Kernel] Do not use references on function/macro definitions - this provides large improvements in compilation times in some rare corner cases
-  * [Supervisor] Support mixing old and new typespecs in `Supervisor.init/2` and `Supevisor.start_link/2`
-
-#### Mix
-
-  * [mix profile] Allow profile tasks to run without a project
+  * [Mix] Add `:archives` configuration to `def project` that allows projects to list archive dependencies. `--no-archives-check` (as well as `--no-deps-check`) will disable the archive check. The `:archives` option is not checked for dependencies.
+  * [Mix] Add `deps.precompile` task as hook
+  * [Mix] Support `--include-children` in `mix deps.compile` option
+  * [String] Update version of the Unicode database to 8.0.0
 
 ### 2. Bug fixes
 
-#### EEx
+  * [Application] Ensure `spec/2` returns nil for unknown applications
+  * [Integer] Fix a possible binary leak in `parse/1`
+  * [Mix] Purge Erlang modules on recompilation
+  * [String] Ensure `split/1` does not break on non-breakable whitespace
+  * [String] Ensure NFC and NFD normalization pass all of Unicode 8.0.0 tests
+  * [Version] Allow dots in build info for versions in `Version.parse/1`
 
-  * [EEx.Engine] Do not re-use the value of the `init/1` callback throughout the compilation stack
+## v1.2.3 (2016-02-21)
 
-#### Elixir
+### 1. Enhancements
 
-  * [Kernel] Ensure dialyzer does not emit warnings in some uses of `with`
-  * [Kernel] Fix dialyzer warnings when `defmacrop` is used in modules
-  * [Kernel] Ensure Elixir modules can be dialyzed without starting the Elixir application
-  * [Kernel] Do not serialize references in quoted expressions
-  * [Kernel] Make sure structs expansion use the latest definition available when struct modules are recompiled
-  * [Task] Support `:infinity` timeout on Task streams
-  * [Typespec] Ensure typespecs allow `tuple` to be used as variable names
+  * [Base] Add `:ignore` and `:padding` option to encoding/decoding functions
+  * [Mix] Add `Mix.Projects.deps_paths` that returns the dependencies path as a map
 
-## v1.5.0 (2017-07-25)
+### 2. Bug fixes
+
+  * [ExUnit] Do not provide negative line numbers without generated annotation (for compatibility with Erlang 19)
+  * [Mix] Reject non fullfilled optional dependencies later on in the convergence resolution for proper dependency sorting
+  * [String] Fix incomplete data trimming on both `String.replace_trailing` and `String.rstrip`
+  * [String] Attach debug_info back into Unicode modules for Dialyzer support
+
+## v1.2.2 (2016-01-31)
+
+### 1. Enhancements
+
+  * [Kernel] Support `@compile {:autoload, false}` to disable automatic loading after compilation
+
+### 2. Bug fixes
+
+  * [ExUnit] Raise if trying to override reserved tag in `setup` blocks
+  * [Mix] Ensure retrieve compile manifests do fail if some compilers are not yet available
+  * [Mix] Automatically merge managers according to the mix > rebar3 > rebar > make order
+  * [Mix] Force recompilation if dependency was recently fetched
+
+## v1.2.1 (2016-01-14)
+
+### 1. Enhancements
+
+  * [IEx] Support remote pids/ports with IEx helper `i/1`
+  * [Protocol] Warn when `defimpl` is called for a consolidated protocol
+
+### 2. Bug fixes
+
+  * [ExUnit] Ensure `assert` macros can be used from quoted code
+  * [ExUnit] Do not warn in match assertion if variable is reused in pattern
+  * [Macro] Fix a bug in `Macro.to_string/1` where a remote function could be accidentally interpreted as a sigil
+  * [Mix] Ensure dependencies are properly skipped when `--only` option is given to `mix deps.get`
+
+## v1.2.0 (2016-01-01)
 
 ### 1. Enhancements
 
 #### Elixir
 
-  * [Access] Optimize `Access.get/2`
-  * [Base] Optimise Base encode/decode
-  * [Calendar] Implement Inspect for DateTime with Calendar.ISO
-  * [Calendar] Add "ISO days" format for conversions between Calendars and `Date.convert/2`, `Time.convert/2`, `NaiveDateTime.convert/2` and `DateTime.convert/2` (as well as bang variants)
-  * [Calendar] Add `:calendar` field to `Time` struct
-  * [Calendar] Add `Time.diff/3`, `Date.add/2`, `Date.diff/2`, `DateTime.diff/3`
-  * [Calendar] Add `Date.range/2`
-  * [Calendar] Add `Date.new/4`, `DateTime.utc_now/1`, `NaiveDateTime.new/8` and `Time.new/5` that allow specifing calendar
-  * [Enum] Add `Enum.chunk_by/4` and `Stream.chunk_by/4`
-  * [Enum] Add `Enum.chunk_every/2` and `Enum.chunk_every/4` with a more explicit API than `Enum.chunk/2` and `Enum.chunk/4`
-  * [Exception] Add `Exception.blame/3` that adds metadata to exceptions
-  * [File] Add `File.read_link/1` and `File.read_link!/1`
-  * [File] Introduce `:trim_bom` option for `File.stream!/2`
-  * [Inspect] Add `:printable_limit` to control the limit of printable structures
-  * [Integer] Add `Integer.gcd/2`
-  * [Kernel] Add `left not in right` to check that the left side is not in the enumerable on the right
-  * [Kernel] Use the new `debug_info` chunk in OTP 20. This provides a mechanism for tools to retrieve the Elixir AST from beam files
-  * [Kernel] `defoverridable/1` accepts a module name as argument and marks all callbacks as overridable
-  * [Kernel] Allow non-quoted Unicode atoms and variables according to Unicode Annex #31 (see Unicode Syntax document)
-  * [Kernel] Warn when a `:__struct__` key is used when building/updating structs
-  * [Kernel] Cache the AST on definitions. This speeds up the compilation time from 10% to 15% measured across different projects
-  * [Kernel] Improve compiler error message on invalid patterns and guards
-  * [Keyword] Add `replace/3` and `replace!/3` for replacing an existing key
-  * [List] `List.starts_with?/2`
-  * [Macro] Introduce `Macro.generate_arguments/2`
-  * [Map] Optimize `Map.merge/3` by choosing merging direction
-  * [Map] Add `replace/3` and `replace!/3` for replacing an existing key
-  * [Map] Raise `BadMapError` in `Map.equal?/2` when either of the two arguments is not a map
-  * [MapSet] Reduce `MapSet` size when serialized to approximately half
-  * [Process] Add `Process.cancel_timer/2`
-  * [Protocol] Show available implementations on `Protocol.UndefinedError` if the protocol has been consolidated
-  * [Registry] Support ETS guard conditions in `Registry.match/3`
-  * [Registry] Support `parallel: true` in `Registry.dispatch/3`
-  * [Registry] Introduce `Registry.unregister_match/4`
-  * [Stream] Add `Stream.chunk_every/2` and `Stream.chunk_every/4` with a more explicit API than `Stream.chunk/2` and `Stream.chunk/4`
-  * [String] Optimise binary pattern matching in `String.split/1` and `String.trim_*/1`
-  * [Supervisor] Add `Supervisor.init/2` and `Supervisor.child_spec/2`
-  * [Supervisor] Allow `module` and `{module, arg}` to be given to `Supervisor.start_link/2` and invoke `module.child_spec(arg)` on each argument
-  * [Task] Support `:on_timeout` in `Task.async_stream` to control how tasks are terminated
-  * [Task] Add `ordered: false` support to `Task.async_stream`
+  * [Application] Add `spec/1` and `spec/2` to retrieve application specification
+  * [Application] Add `get_application/1` to retrieve the application a given module belongs to
+  * [Base] Optimize encode and decode operations about 10 times
+  * [Enum] Use the faster and auto-seeding `:rand` instead of `:random` in `Enum.shuffle/1` and `Enum.random/1` and `Enum.take_random/2`
+  * [Enum] Add `Enum.with_index/2`
+  * [GenServer] Add `GenServer.stop/1` for shutting down servers reliably
+  * [IO] Add `color` related functions to `IO.ANSI`
+  * [Kernel] Support multiple aliases in `alias`, `import`, `require` and `use`. For example, `alias MyApp.{Foo, Bar, Baz}`
+  * [Kernel] Add `struct!/2`. Similar to `struct/2` but raises on invalid keys
+  * [Kernel] Warn if `@doc/@typedoc/@moduledoc` attributes are redefined
+  * [Kernel] Warn if non-variables are used in `defdelegate/2` (as they have no effect)
+  * [Kernel] Mark quoted expressions as generated, avoiding false positives on dialyzer
+  * [Kernel] Allow variables as map keys on creation `%{key => value}` and on matches `%{^key => value}`
+  * [Kernel] Allow the pin operator `^` in `fn` clauses and on the left side of `<-` in `for` comprehensions
+  * [Kernel] Introduce `with` as a special form that allows matching on right side parameters
+  * [Kernel] Warn when right hand side of `->` does not provide any expression
+  * [Kernel] Warn if the Elixir was compiled with a different endianness than the one currently available at runtime
+  * [Kernel] Warn if a variable is used after being defined exclusively in a nested context
+  * [Kernel] Warn if piping into an expression without parentheses
+  * [Macro] Add `Macro.traverse/4` that performs pre and post-walk at once
+  * [Macro] Add `Macro.camelize/1` and `Macro.underscore/1`
+  * [Process] Add `Process.get_keys/0`
+  * [Stream] Add `Stream.with_index/2`
+  * [String] Introduce `String.replace_{prefix,suffix,leading,trailing}/2`. The first two will replace only the first occurrence of the given match in string. The last two will replace all occurrences of the given match
+  * [String] Support `String.normalize/2` and `String.equivalent?/2` that perform NFD and NFC normalization
+  * [System] Add `System.time_offset`, `System.monotonic_time`, `System.system_time`, `System.convert_time_unit` and `System.unique_integer`
+  * [System] Allow `System.cmd/3` to remove variables by specifying nil values
+  * [Task] Add `Task.Supervisor.async_nolink/1/3` that spawns a supervised task without linking to the caller process
+  * [Task] Introduce `Task.yield_many/2`
+  * [Task] Raise an error when a task is queried from a non-owning process (instead of waiting forever)
 
 #### ExUnit
 
-  * [ExUnit] Show code snippet from test source file in case of test errors
-  * [ExUnit] Use `Exception.blame/3` when formatting test errors
-  * [ExUnit] Make `assert_raise/2` fail if the underlying exception has a broken `message/1` implementation
-  * [ExUnit] Add `start_supervised/2` and `stop_supervised/1` to ExUnit. Processes started by this function are automatically shut down when the test exits
+  * [ExUnit] Allow one test to raise multiple errors. The goal is to enable tools in the ecosystem to emit multiple failure reports from the same test
+  * [ExUnit] Support `@tag report: [:foo, :bar]` which will include the values for tags `:foo` and `:bar` whenever a test fails
 
 #### IEx
 
-  * [IEx.Autocomplete] Support autocompletion of variable names
-  * [IEx.Autocomplete] Support autocompletion of functions imported using `import Mod, only: [...]`
-  * [IEx.Evaluator] Use `Exception.blame/3` when showing errors in the terminal
-  * [IEx.Helpers] Add `exports/1` IEx helper to list all exports in a module
-  * [IEx.Helpers] Add `break!/2`, `break!/4`, `breaks/0`, `continue/0`, `open/0`, `remove_breaks/0`, `remove_breaks/1`, `reset_break/1`, `reset_break/3` and `whereami/1` for code debugging
-  * [IEx.Helpers] No longer emit warnings for IEx commands without parentheses
-  * [IEx.Helpers] Add `runtime_info/0` for printing runtime system information
-  * [IEx.Helpers] Add `open/1` to open the source of a given module/function in your editor
-  * [IEx.Info] Implement `IEx.Info` protocol for calendar types
+  * [IEx] Allow `IEX_WITH_WERL` to be set on Windows to always run on WERL mode
+  * [IEx] Display type docs for `t(Module.type)` and `t(Module.type/arity)`
+  * [IEx] Add `i/1` helper that prints information about any data type
+  * [IEx] Show source code snippet whenever there is a request to pry a given process
 
 #### Logger
 
-  * [Logger] Add `metadata: :all` configuration to log all metadata
+  * [Logger] Add file to logger metadata
 
 #### Mix
 
-  * [mix compile.elixir] Add `--all-warnings` option to Elixir compiler that shows all warnings from the previous compilation (instead of just of the files being compiled)
-  * [mix escript.build] Strip debug information from escripts by default and add option `:strip_beam` which defaults to true
-  * [mix loadpaths] Ensure `--no-deps-check` do not trigger SCM callbacks (such as `git`)
-  * [mix local.hex] Add `--if-missing` flag to `local.hex` mix task
-  * [mix profile.cprof] Add `Mix.Tasks.Profile.Cprof` for count-based profiling
-  * [mix new] New styling for generated applications
+  * [Mix] Cache and always consolidate protocols
+  * [Mix] Add `warn_test_pattern` to `mix test` that will warn on potentially misconfigured test files
+  * [Mix] Introduce `MIX_QUIET` environment variable that configures the underlying Mix task to output only error messages
+  * [Mix] Introduce `MIX_DEBUG` environment variable that prints information about the task being run
+  * [Mix] Validate git options and warn on conflicting ref, branch or tags
+  * [Mix] New umbrella applications will now share configuration and build files
+  * [Mix] Add experimental support for Rebar 3
+  * [Mix] Do not warn when an optional dependency has a conflicting `:only` option with another dependency
+  * [Mix] Raise readable error message when parsertools is not available
+  * [Mix] Add `--build` flag to `mix deps.clean DEP` to only remove artifacts from `_build`
 
 ### 2. Bug fixes
 
-#### Elixir
+#### Kernel
 
-  * [Calendar] Ensure `Calendar.ISO` raises a readable error when reaching up the year 10000 restriction
-  * [Calendar] Return `{:error, :invalid_time}` for wrong precision instead of crashing when parsing ISO dates
-  * [Enumerable] Raise `Protocol.UndefinedError` on bad functions in Enumerable implementation
-  * [File] Ensure recursive file operations raise on paths with null bytes (*security issue reported by Griffin Byatt*)
-  * [File] Support `:ram`/`:raw` files in `File.copy/2`
-  * [Inspect] Do not use colors when inspecting error messages
-  * [Kernel] Support guards on anonymous functions of zero arity
-  * [Kernel] Fix compilation of maps used as maps keys inside matches
-  * [Kernel] Ensure `do` clause in `with` is tail call optimizable
-  * [Module] `on_definition/6` callback receives body wrapped in a keyword list, such as `[do: body]`. This solves a bug where it was impossible to distinguish between a bodyless clause and a function that returns `nil`.
-  * [Path] Ensure recursive path operations raise on paths with null bytes (*security issue reported by Griffin Byatt*)
-  * [Protocol] Do not lose source compile info on protocol consolidation
-  * [Record] Properly escape quoted expressions passed to `defrecord`
-  * [Regex] Fix `inspect/2` for regexes with `/` terminator in them
-  * [Registry] Ensure `Registry.match/4` works with `:_` as key
-  * [Stream] Fix stream cycle over empty enumerable
-  * [String] Consider Unicode non-characters valid according to the specification in `String.valid?/1`
-  * [StringIO] Fix encoding and performance issues in `StringIO.get_until`
-  * [System] Raise on paths with null bytes in `System.cmd/2` and in `System.find_executable/1` (*security issue reported by Griffin Byatt*)
-  * [System] Raise on ill-formed environment variables (*security issue reported by Griffin Byatt*)
-
-#### ExUnit
-
-  * [ExUnit] Properly account failed tests when `setup_all` fails
-  * [ExUnit] Having two or more `describe` blocks with the same name will now raise an error.
+  * [Access] Improve error messages when using Access on non-valid key-value structures
+  * [Kernel] Raise when conflicting `:only` and `:except` are given to import
+  * [Kernel] Change `__ENV__.file` if `@file` is set for the given function
+  * [Kernel] Make `Kernel.ParallelRequire` aware of `:warning_as_errors`
+  * [Kernel] Improve error message for invalid `do`/`do:`
+  * [Macro] Ensure `Macro.to_string/2` respects operator precedence when using the access operator
+  * [Path] Do not crash when expanding paths that go beyond the root, for example, `Path.expand("/../..")`
+  * [String] Ensure `UnicodeConversionError` does not contain invalid string in its error message
 
 #### IEx
 
-  * [IEx] Skip autocompletion of module names that are invalid without being quoted
-  * [IEx] Skip autocompletion of functions with default arguments with `@doc false`
-  * [IEx] Do not start oldshell alongside IEx
+  * [IEx] Do not start apps on `recompile` helper if `--no-start` was given
+  * [IEx] Avoid copying of data when evaluating every expression in IEx
 
 #### Mix
 
-  * [mix compile.elixir] Store multiple sources in case of module conflicts. This solves an issue where `_build` would get corrupted when compiling Elixir projects with module conflicts
-  * [mix compile.erlang] Do not silently discard Erlang compile errors
-  * [mix compile.erlang] Properly track `-compile` module attribute when specified as a list
-  * [mix compile.protocols] Ensure protocol implementations do not "disappear" when switching between applications in umbrella projects by having separate consolidation paths per project
-  * [mix compile.protocols] Do not raise when consolidating a protocol that was converted into a module
+  * [Mix] Always run non-recursive tasks at the umbrella root
+  * [Mix] Ensure rebar projects work on directory names that contain non-latin characters
+  * [Mix] Ignore directories inside `apps` in umbrellas that do not have a `mix.exs` file
+  * [Mix] Ensure Mix can be used with path dependencies where the app name is different than the path basename
+  * [Mix] Ensure dependencies won't crash when updating from a git repository to a hex repository and the git version did not respect SemVer
+  * [Mix] Do not run remote converger if dependencies have diverged
+  * [Mix] Ensure umbrella dependencies across all environments are loaded on parent deps.get/deps.update
+
+#### ExUnit
+
+  * [ExUnit] Include file and line in all compilation errors for doctests
 
 ### 3. Soft deprecations (no warnings emitted)
 
-#### Elixir
+#### Kernel
 
-  * [Kernel] `not left in right` is soft-deprecated in favor of `left not in right`
+  * [Dict] `Dict` and `HashDict` are soft deprecated in favor of `Map`
+  * [Keyword] `Keyword.size/1` is deprecated in favor of `length/1`
+  * [Map] `Map.size/1` is deprecated in favor of `map_size/1`
+  * [Set] `Set` and `HashSet` are soft deprecated in favor of `MapSet`
 
-### 4. Deprecations
+#### Mix
 
-#### Elixir
+  * [Mix] `Mix.Utils.camelize/1` and `Mix.Utils.underscore/1` are soft deprecated in favor of `Macro.camelize/1` and `Macro.underscore/1`
 
-  * `Atom.to_char_list/1`, `Float.to_char_list/1`, `Integer.to_char_list/1`, `Integer.to_char_list/2`, `Kernel.to_char_list/1`, `List.Chars.to_char_list/1`, `String.to_char_list/1` have been deprecated in favor of their `to_charlist` version. This aligns with the naming conventions in both Erlang and Elixir
-  * [Enum] Deprecate `Enum.filter_map/3` in favor of `Enum.filter/2` + `Enum.map/2` or for-comprehensions
-  * [GenEvent] Deprecate `GenEvent` and provide alternatives in its docs
-  * [Kernel] Using `()` to mean `nil` is deprecated
-  * [Kernel] `:as_char_lists value` in `Inspect.Opts.t/0` type, in favor of `:as_charlists`
-  * [Kernel] `:char_lists` key in `Inspect.Opts.t/0` type, in favor of `:charlists`
-  * [Module] Using Erlang parse transforms via `@compile {:parse_transform, _}` is deprecated
-  * [Stream] Deprecate `Stream.filter_map/3` in favor of `Stream.filter/2` + `Stream.map/2`
-  * [String] `String.ljust/3` and `String.rjust/3` are deprecated in favor of `String.pad_leading/3` and `String.pad_trailing/3` with a binary padding
-  * [String] `String.strip/1` and `String.strip/2` are deprecated in favor of `String.trim/1` and `String.trim/2`
-  * [String] `String.lstrip/1` and `String.rstrip/1` are deprecated in favor of `String.trim_leading/1` and `String.trim_trailing/1`
-  * [String] `String.lstrip/2` and `String.rstrip/2` are deprecated in favor of `String.trim_leading/2` and `String.trim_trailing/2` with a binary as second argument
-  * [Typespec] `char_list/0` type is deprecated in favor of `charlist/0`
+## v1.1
 
-#### EEx
-
-  * [EEx] Deprecate `<%= ` in "middle" and "end" expressions, e.g.: `<%= else %>` and `<%= end %>`
-
-## v1.4
-
-The CHANGELOG for v1.4 releases can be found [in the v1.4 branch](https://github.com/elixir-lang/elixir/blob/v1.4/CHANGELOG.md).
+The CHANGELOG for v1.1 releases can be found [in the v1.1 branch](https://github.com/elixir-lang/elixir/blob/v1.1/CHANGELOG.md).

CODE_OF_CONDUCT.md

@@ -1,56 +1,22 @@
-# Code of Conduct
+# Contributor Code of Conduct
 
-Contact: elixir-lang-conduct@googlegroups.com
+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
 
-## Why have a Code of Conduct?
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
 
-As contributors and maintainers of this project, we are committed to providing a friendly, safe and welcoming environment for all, regardless of age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
+Examples of unacceptable behavior by participants include:
 
-The goal of the Code of Conduct is to specify a baseline standard of behavior so that people with different social values and communication styles can talk about Elixir effectively, productively, and respectfully, even in face of disagreements. The Code of Conduct also provides a mechanism for resolving conflicts in the community when they arise.
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic addresses, without explicit permission
+* Other unethical or unprofessional conduct.
 
-## Our Values
+The Elixir Core Team has the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. By adopting this Code of Conduct, we commit ourselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
 
-These are the values Elixir developers should aspire to:
+This code of conduct applies both within project spaces and in public spaces when an individual is representing the project or its community.
 
-  * Be friendly and welcoming
-  * Be patient
-    * Remember that people have varying communication styles and that not everyone is using their native language. (Meaning and tone can be lost in translation.)
-  * Be thoughtful
-    * Productive communication requires effort. Think about how your words will be interpreted.
-    * Remember that sometimes it is best to refrain entirely from commenting.
-  * Be respectful
-    * In particular, respect differences of opinion. It is important that we resolve disagreements and differing views constructively.
-  * Avoid destructive behavior
-    * Derailing: stay on topic; if you want to talk about something else, start a new conversation.
-    * Unconstructive criticism: don't merely decry the current state of affairs; offer (or at least solicit) suggestions as to how things may be improved.
-    * Snarking (pithy, unproductive, sniping comments).
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by sending an e-mail to elixir-lang-conduct@googlegroups.com.
 
-The following actions are explicitly forbidden:
-
-  * Insulting, demeaning, hateful, or threatening remarks.
-  * Discrimination based on age, disability, gender, nationality, race, religion, sexuality, or similar personal characteristic.
-  * Bullying or systematic harassment.
-  * Unwelcome sexual advances.
-  * Incitement to any of these.
-
-## Where does the Code of Conduct apply?
-
-If you participate in or contribute to the Elixir ecosystem in any way, you are encouraged to follow the Code of Conduct while doing so.
-
-Explicit enforcement of the Code of Conduct applies to the official mediums operated by the Elixir project:
-
-* The official GitHub projects and code reviews.
-* The official elixir-lang mailing lists.
-* The #elixir-lang IRC channel on Freenode.
-
-Other Elixir activities (such as conferences, meetups, and other unofficial forums) are encouraged to adopt this Code of Conduct. Such groups must provide their own contact information.
-
-Project maintainers may remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by emailing: elixir-lang-conduct@googlegroups.com. All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances. **All reports will be kept confidential**.
-
-**The goal of the Code of Conduct is to resolve conflicts in the most harmonious way possible**. We hope that in most cases issues may be resolved through polite discussion and mutual agreement. Bannings and other forceful measures are to be employed only as a last resort. **Do not** post about the issue publicly or try to rally sentiment against a particular individual or group.
-
-## Acknowledgements
-
-This document was based on the Code of Conduct from the Go project with parts derived from Django's Code of Conduct, Rust's Code of Conduct and the Contributor Covenant.
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.2.0, available at [http://contributor-covenant.org/version/1/2/0/](http://contributor-covenant.org/version/1/2/0/)

CONTRIBUTING.md

@@ -0,0 +1,275 @@
+# Contributing to Elixir
+
+Please take a moment to review this document in order to make the contribution
+process easy and effective for everyone involved!
+
+Also make sure you read our [Code of Conduct](CODE_OF_CONDUCT.md) that
+outlines our commitment towards an open and welcoming environment.
+
+## Using the issue tracker
+
+Use the issues tracker for:
+
+* [bug reports](#bug-reports)
+* [submitting pull requests](#pull-requests)
+
+Please **do not** use the issue tracker for personal support requests nor feature requests. Support requests should be sent to:
+
+* [the elixir-talk mailing list](https://groups.google.com/group/elixir-lang-talk)
+* [Stack Overflow](http://stackoverflow.com/questions/ask?tags=elixir)
+* **[#elixir-lang](irc://chat.freenode.net/elixir-lang)** IRC channel on [chat.freenode.net](http://www.freenode.net/)
+
+Feature requests can be discussed on [the elixir-core mailing list](https://groups.google.com/group/elixir-lang-core).
+
+We do our best to keep the issue tracker tidy and organized, making it useful
+for everyone. For example, we classify open issues per application and perceived
+difficulty of the issue, making it easier for developers to
+[contribute to Elixir](#contributing).
+
+## Bug reports
+
+A bug is a _demonstrable problem_ that is caused by the code in the repository.
+Good bug reports are extremely helpful - thank you!
+
+Guidelines for bug reports:
+
+1. **Use the GitHub issue search** — [check if the issue has already been
+   reported](https://github.com/elixir-lang/elixir/search?type=Issues).
+
+2. **Check if the issue has been fixed** — try to reproduce it using the
+   `master` branch in the repository.
+
+3. **Isolate and report the problem** — ideally create a reduced test
+   case.
+
+Please try to be as detailed as possible in your report. Include information about
+your Operating System, your Erlang and Elixir versions. Please provide steps to
+reproduce the issue as well as the outcome you were expecting! All these details
+will help developers to fix any potential bugs.
+
+Example:
+
+> Short and descriptive example bug report title
+>
+> A summary of the issue and the environment in which it occurs. If suitable,
+> include the steps required to reproduce the bug.
+>
+> 1. This is the first step
+> 2. This is the second step
+> 3. Further steps, etc.
+>
+> `<url>` - a link to the reduced test case (e.g. a GitHub Gist)
+>
+> Any other information you want to share that is relevant to the issue being
+> reported. This might include the lines of code that you have identified as
+> causing the bug, and potential solutions (and your opinions on their
+> merits).
+
+## Feature requests
+
+Feature requests are welcome and should be discussed on [the elixir-core mailing list](https://groups.google.com/group/elixir-lang-core). But take a moment to find
+out whether your idea fits with the scope and aims of the project. It's up to *you*
+to make a strong case to convince the community of the merits of this feature.
+Please provide as much detail and context as possible.
+
+## Contributing
+
+We incentivize 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
+
+* `eex` - Template engine that allows you to embed Elixir
+
+* `ex_unit` - Simple test framework that ships with Elixir
+
+* `iex` - IEx, Elixir's interactive shell
+
+* `mix` - Elixir's build tool
+
+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`.
+
+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:
+
+```sh
+bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
+bin/elixir lib/elixir/test/elixir/string_test.exs
+```
+
+After your changes are done, please remember to run the full suite with
+`make test`.
+
+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 your pull requests.
+
+## Contributing Documentation
+
+Code documentation (`@doc`, `@moduledoc`, `@typedoc`) has a special convention:
+the first paragraph is considered to be a short summary.
+
+For functions, macros and callbacks say what it will do. For example write
+something like:
+
+```elixir
+@doc """
+Returns only those elements for which `fun` is `true`.
+
+...
+"""
+def filter(collection, fun) ...
+```
+
+For modules, protocols and types say what it is. For example write
+something like:
+
+```elixir
+defmodule File.Stat do
+  @moduledoc """
+  Information about a file.
+
+  ...
+  """
+
+  defstruct [...]
+end
+```
+
+Keep in mind that the first paragraph might show up in a summary somewhere, long
+texts in the first paragraph create very ugly summaries. As a rule of thumb
+anything longer than 80 characters is too long.
+
+Try to keep unnecessary details out of the first paragraph, it's only there to
+give a user a quick idea of what the documented "thing" does/is. The rest of the
+documentation string can contain the details, for example when a value and when
+`nil` is returned.
+
+If possible include examples, preferably in a form that works with doctests. For
+example:
+
+```elixir
+@doc """
+Returns only those elements for which `fun` is `true`.
+
+## Examples
+
+    iex> Enum.filter([1, 2, 3], fn(x) -> rem(x, 2) == 0 end)
+    [2]
+
+"""
+def filter(collection, fun) ...
+```
+
+This makes it easy to test the examples so that they don't go stale and examples
+are often a great help in explaining what a function does.
+
+## Pull requests
+
+Good pull requests - patches, improvements, new features - are a fantastic
+help. They should remain focused in scope and avoid containing unrelated
+commits.
+
+**NOTE**: Do not send code style changes as pull requests like changing
+the indentation of some particular code snippet or how a function is called.
+Those will not be accepted as they pollute the repository history with non
+functional changes and are often based on personal preferences.
+
+**IMPORTANT**: By submitting a patch, you agree that your work will be
+licensed under the license used by the project.
+
+If you have any large pull request in mind (e.g. implementing features,
+refactoring code, etc), **please ask first** otherwise you risk spending
+a lot of time working on something that the project's developers might
+not want to merge into the project.
+
+Please adhere to the coding conventions in the project (indentation,
+accurate comments, etc.) and don't forget to add your own tests and
+documentation. When working with Git, we recommend the following process
+in order to craft an excellent pull request:
+
+1. [Fork](https://help.github.com/fork-a-repo/) the project, clone your fork,
+  and configure the remotes:
+
+  ```sh
+  # Clone your fork of the repo into the current directory
+  git clone https://github.com/<your-username>/elixir
+  # Navigate to the newly cloned directory
+  cd elixir
+  # Assign the original repo to a remote called "upstream"
+  git remote add upstream https://github.com/elixir-lang/elixir
+  ```
+
+2. If you cloned a while ago, get the latest changes from upstream:
+
+  ```sh
+  git checkout master
+  git pull upstream master
+  ```
+
+3. Create a new topic branch (off of `master`) to contain your feature, change,
+  or fix.
+
+  **IMPORTANT**: Making changes in `master` is discouraged. You should always
+  keep your local `master` in sync with upstream `master` and make your
+  changes in topic branches.
+
+  ```sh
+  git checkout -b <topic-branch-name>
+  ```
+
+4. Commit your changes in logical chunks. Keep your commit messages organized,
+  with a short description in the first line and more detailed information on
+  the following lines. Feel free to use Git's
+  [interactive rebase](https://help.github.com/articles/interactive-rebase)
+  feature to tidy up your commits before making them public.
+
+5. Make sure all the tests are still passing.
+
+  ```sh
+  make test
+  ```
+
+  This command will compile the code in your branch and use that
+  version of Elixir to run the tests. This is needed to ensure your changes can
+  pass all the tests.
+
+6. Push your topic branch up to your fork:
+
+  ```sh
+  git push origin <topic-branch-name>
+  ```
+
+7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
+  with a clear title and description.
+
+8. If you haven't updated your pull request for a while, you should consider
+  rebasing on master and resolving any conflicts.
+
+  **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You
+  should always `git rebase` on `master` to bring your changes up to date when
+  necessary.
+
+  ```sh
+  git checkout master
+  git pull upstream master
+  git checkout <your-topic-branch>
+  git rebase master
+  ```
+
+We have saved some excellent pull requests we have received in the past in case
+you are looking for some examples:
+
+* [Implement Enum.member? – Pull Request](https://github.com/elixir-lang/elixir/pull/992)
+* [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)
+
+Thank you for your contributions!

ISSUE_TEMPLATE.md

@@ -1,18 +0,0 @@
-### Precheck
-
-* Do not use the issues tracker for help or support (try Elixir Forum, Stack Overflow, IRC, 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 versions (elixir --version): 
-* Operating system: 
-
-### Current behavior
-
-Include code samples, errors and stacktraces if appropriate.
-
-### Expected behavior
-

Makefile

@@ -1,31 +1,28 @@
 REBAR ?= "$(CURDIR)/rebar"
 PREFIX ?= /usr/local
-SHARE_PREFIX ?= $(PREFIX)/share
-CANONICAL := v1.5/
+DOCS := v1.2
+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
 VERSION := $(strip $(shell cat VERSION))
 Q := @
 LIBDIR := lib
-BINDIR := bin
 INSTALL = install
 INSTALL_DIR = $(INSTALL) -m755 -d
 INSTALL_DATA = $(INSTALL) -m644
 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 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
-	$(Q) erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 18)])' -s erlang halt | grep -q '^true'; \
-		if [ $$? != 0 ]; then \
-		  echo "At least Erlang 18.0 is required to build Elixir"; \
-		  exit 1; \
+	$(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 18.0 is required to build Elixir";                                                          \
+		   exit 1;                                                                                                           \
 		fi;
 endef
 
@@ -60,38 +57,37 @@ compile: lib/elixir/src/elixir.app.src erlang elixir
 
 lib/elixir/src/elixir.app.src: src/elixir.app.src
 	$(Q) $(call CHECK_ERLANG_RELEASE)
-	$(Q) rm -f lib/elixir/src/elixir.app.src
+	$(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
+	                             >lib/elixir/src/elixir.app.src
 	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
 
 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) rm -f lib/elixir/ebin/elixir.app
+	$(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;
+	@ echo "Embedding the Unicode database... (this may take a while)"
+	$(Q) cd lib/elixir && ../../$(ELIXIRC) unicode/unicode.ex -o ebin;
 
 $(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
 $(eval $(call APP_TEMPLATE,logger,Logger))
@@ -102,15 +98,15 @@ $(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
 
@@ -118,36 +114,29 @@ clean:
 	cd lib/elixir && $(REBAR) clean
 	rm -rf ebin
 	rm -rf lib/*/ebin
-	rm -f lib/elixir/src/elixir.app.src
-	$(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)
+SOURCE_REF = $(shell head="$$(git rev-parse HEAD)" tag="$$(git tag --points-at $$head | tail -1)" ; echo "$${tag:-$$head}\c")
+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 "v$(VERSION)" $(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,-e "lib/elixir/pages/Behaviours.md" -e "lib/elixir/pages/Deprecations.md" -e "lib/elixir/pages/Guards.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Operators.md" -e "lib/elixir/pages/Syntax Reference.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Unicode Syntax.md" -e "lib/elixir/pages/Writing Documentation.md")
+	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-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)"
@@ -178,30 +167,30 @@ 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
+	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
+#==> Publish
 
-#==> Test tasks
+publish_zips: Precompiled.zip Docs.zip
+
+publish_docs: docs
+	rm -rf ../docs/$(DOCS)/*/
+	cp -R doc/* ../docs/$(DOCS)
+
+#==> Tests tasks
 
 test: test_erlang test_elixir
 
-test_windows: test test_taskkill
-
-test_taskkill:
-	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
-	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
-
 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)))))
@@ -252,24 +241,22 @@ man/iex.1:
 	$(Q) cp man/iex.1.in 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 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,18 +1,15 @@
 ![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)
-[![Windows build](https://ci.appveyor.com/api/projects/status/macwuxq7aiiv61g1?svg=true)](https://ci.appveyor.com/project/josevalim/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:
+If you want to contribute to Elixir or run it from source, clone this
+repository to your machine, compile and test it:
 
 ```sh
 git clone https://github.com/elixir-lang/elixir.git
@@ -28,122 +25,26 @@ 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 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:
+(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 18 [erts-7.0] [source] [smp:2:2] [async-threads:10] [hipe] [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.
-
-## Contributing
-
-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
-
-* `eex` - Template engine that allows you to embed Elixir
-
-* `ex_unit` - Simple test framework that ships with Elixir
-
-* `iex` - IEx, Elixir's interactive shell
-
-* `logger` - The built-in logger
-
-* `mix` - Elixir's build tool
-
-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`, as
-`test_elixir` also runs tests for the other projects (EEx, ExUnit, etc.).
-
-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:
-
-```sh
-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
-```
-
-If your contribution fails the build during the bootstrapping of the language,
-you can reproduce it locally by deleting all of Elixir beam files and compiling
-again:
-
-```sh
-make clean_elixir compile
-```
-
-Or to rebuild everything from scratch without running tests:
-
-```sh
-make clean compile
-```
-
-More tasks can be found by reading the [Makefile](./Makefile).
-
-After your changes are done, please remember to run the full suite with
-`make test`.
-
-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/).
-We have saved some excellent pull requests we have received in the past in
-case you are looking for some examples:
-
-* [Implement Enum.member? – Pull Request](https://github.com/elixir-lang/elixir/pull/992)
-* [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)
-
-We usually keep a list of enhancements and bugs [in the issue tracker][2].
-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. Finally, remember all interactions in our official
-spaces follow our [Code of Conduct][7].
-
-### 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. In case any changes are necessary, the team will leave
-appropriate comments requesting changes to the code.
-
-The Elixir team may optionally assign someone to review a pull request.
-In case someone is assigned, they must explicitly approve the code before
-another team member can merge it.
-
-When review is completed, your pull request will be squashed and merged
-into the repository.
+If you have the correct version and tests still fail, feel free to
+[open an issue][2].
 
 ## Building documentation
 
-Building the documentation requires [ExDoc](https://github.com/elixir-lang/ex_doc)
-to be installed and built alongside Elixir:
+Building the documentation requires
+[ExDoc](https://github.com/elixir-lang/ex_doc) to be installed and built
+alongside Elixir.
 
 ```sh
 # After cloning and compiling Elixir, in its parent directory:
@@ -152,26 +53,31 @@ cd ex_doc && ../elixir/bin/mix do deps.get, compile
 cd ../elixir && make docs
 ```
 
-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).
+This will produce documentation sets for `elixir`, `mix`, etc., under the `doc` directory.
 
-## Development links
+## Contributing
 
-  * [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
+We appreciate any contribution to Elixir.
+Check our [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) and
+[CONTRIBUTING.md](CONTRIBUTING.md) guides for more information.
+We usually keep a list of features and bugs [in the issue tracker][2].
+
+## Important links
+
+* [Elixir Website][1]
+* [Elixir Documentation][7]
+* **[#elixir-lang][5]** on [Freenode][6] IRC
+* [Issue tracker][2]
+* [elixir-talk Mailing list (questions)][3]
+* [elixir-core Mailing list (development)][4]
 
   [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
-  [5]: http://www.freenode.net
-  [6]: http://elixir-lang.org/docs.html
-  [7]: CODE_OF_CONDUCT.md
+  [3]: https://groups.google.com/group/elixir-lang-talk
+  [4]: https://groups.google.com/group/elixir-lang-core
+  [5]: https://webchat.freenode.net/?channels=#elixir-lang
+  [6]: http://www.freenode.net
+  [7]: http://elixir-lang.org/docs.html
 
 ## License
 

RELEASE.md

@@ -10,26 +10,32 @@ This document simply outlines the release process:
 
 3. Ensure CHANGELOG is updated and add current date
 
-4. If a new `vMAJOR.MINOR`, replace "master" with "vVERSION" in the "Deprecations" page and commit
+4. Commit changes above with title "Release vVERSION" and generate new tag
 
-5. If a new `vMAJOR.MINOR`, create a new branch "vMAJOR.MINOR" and set `CANONICAL=` in Makefile
+5. Run `make clean test` to ensure all tests pass from scratch and the CI is green
 
-6. Commit changes above with title "Release vVERSION" and generate new tag
+6. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
 
-7. Run `make clean test` to ensure all tests pass from scratch and the CI is green
+7. Push branch and the new tag
 
-8. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
+8. Publish new docs with `make publish_docs`, copy docs to `docs/stable` if appropriate, and push to GitHub Pages
 
-9. Push branch and the new tag
+9. Publish new zips with `make publish_zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
 
-10. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
+10. Add the release to `elixir.csv` file in `elixir-lang/elixir-lang.github.com`
 
-11. Add the release to `elixir.csv` and `_data/elixir-versions.yml` files in `elixir-lang/elixir-lang.github.com`
+11. Build and push standalone Mix with `make publish_mix` (requires AWS credentials)
 
-12. After a new `vMAJOR.MINOR`, move back to master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vMAJOR.MINOR+1"
+## New vMAJOR.MINOR releases
+
+12. Create a new branch "vMAJOR.MINOR"
+
+13. Move docs generation to `docs/vMAJOR.MINOR` in Makefile and copy them from `docs/stable` (change index.html accordingly)
+
+14. In master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vVERSION+1"
 
 ## Places where version is mentioned
 
-* VERSION
+* VERSION (make sure there is no newline in this file)
 * CHANGELOG.md
 * src/elixir.app.src (not lib/elixir/src/elixir.app.src)

VERSION

@@ -1 +1 @@
-1.5.3
+1.2.6

bin/elixir

@@ -2,26 +2,22 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -pr FILE                    Requires the given files/patterns in parallel (*)
-  -pa PATH                    Prepends the given path to Erlang code path (*)
-  -pz PATH                    Appends the given path to Erlang code path (*)
-
-  --app APP                   Starts the given app and its dependencies (*)
-  --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)
+  -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
+  -pr \"file\"        Requires the given files/patterns in parallel (*)
+  -pa \"path\"        Prepends the given path to Erlang code path (*)
+  -pz \"path\"        Appends the given path to Erlang code path (*)
+  --app \"app\"       Start the given app and its dependencies (*)
+  --erl \"switches\"  Switches to be passed down to Erlang (*)
+  --name \"name\"     Makes and assigns a name to the distributed node
+  --sname \"name\"    Makes and assigns a short name to the distributed node
+  --cookie \"cookie\" Sets a cookie for this distributed node
+  --hidden          Makes a hidden node
+  --detached        Starts the Erlang VM detached from console
+  --werl            Uses Erlang's Windows shell GUI (Windows only)
+  --no-halt         Does not halt the Erlang VM after execution
 
 ** Options marked with (*) can be given more than once
 ** Options given after the .exs file or -- are passed down to the executed code
@@ -72,20 +68,6 @@ while [ $I -le $# ]; do
         eval "VAL=\${$I}"
         ERL="$ERL `echo $PEEK | cut -c 2-` "$VAL""
         ;;
-    --logger-otp-reports)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        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
-            ERL="$ERL -logger handle_sasl_reports "$VAL""
-        fi
-        ;;
     --erl)
         I=$(expr $I + 1)
         eval "VAL=\${$I}"

bin/elixir.bat

@@ -1,39 +1,34 @@
-@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 ""%1""==""--help"" goto :documentation
+if ""%1""==""-h""     goto :documentation
+if ""%1""==""/h""     goto :documentation
 goto parseopts
 
 :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.
-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   -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
+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   --app app         Start the given app and its dependencies (*)
+echo   --erl switches    Switches to be passed down to erlang (*)
+echo   --name name       Makes and assigns a name to the distributed node
+echo   --sname name      Makes and assigns a short name to the distributed node
+echo   --cookie cookie   Sets a cookie for this distributed node
+echo   --hidden          Makes a hidden node
+echo   --detached        Starts the Erlang VM detached from console
+echo   --werl            Uses Erlang's Windows shell GUI
+echo   --no-halt         Does not halt the Erlang VM after execution
 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
-echo ** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS or --erl
+echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS or --erl
 goto end
 
 :parseopts
@@ -62,52 +57,49 @@ 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")
-rem ******* ELIXIR PARAMETERS **********************
+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:--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,19 +2,16 @@
 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
+  --ignore-module-conflict
+  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  --verbose        Print informational messages.
 
 ** Options given after -- are passed down to the executed code
-** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS
-** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS" >&2
+** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTIONS
+** Options can be passed to the erlang compiler using ERL_COMPILER_OPTIONS" >&2
   exit 1
 fi
 

bin/elixirc.bat

@@ -1,12 +1,10 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
-setlocal
+@if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
 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 "%%A"=="--help" goto documentation
+    if "%%A"=="-h"     goto documentation
+    if "%%A"=="/h"     goto documentation
+    set /A argc+=1
 )
 if %argc%==0 goto documentation
 goto run
@@ -14,23 +12,15 @@ 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  --ignore-module-conflict
+echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  --verbose        Print informational messages.
 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
-echo ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS
-goto end
-
+echo ** Options can be passed to the Erlang compiler using ERL_COMPILER_OPTIONS >&2
 :run
 call "%~dp0\elixir.bat" +elixirc %*
-
-:end
-endlocal

bin/iex

@@ -2,30 +2,24 @@
 if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -pr FILE                    Requires the given files/patterns in parallel (*)
-  -pa PATH                    Prepends the given path to Erlang code path (*)
-  -pz PATH                    Appends the given path to Erlang code path (*)
-
-  --app APP                   Starts the given app and its dependencies (*)
-  --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;
-                              path can be empty, then no file will be loaded
-  --remsh NAME                Connects to a node using a remote shell
+  -v                Prints version
+  -e \"command\"      Evaluates the given command (*)
+  -r \"file\"         Requires the given files/patterns (*)
+  -S \"script\"       Finds and executes the given script
+  -pr \"file\"        Requires the given files/patterns in parallel (*)
+  -pa \"path\"        Prepends the given path to Erlang code path (*)
+  -pz \"path\"        Appends the given path to Erlang code path (*)
+  --app \"app\"       Start the given app and its dependencies (*)
+  --erl \"switches\"  Switches to be passed down to Erlang (*)
+  --name \"name\"     Makes and assigns a name to the distributed node
+  --sname \"name\"    Makes and assigns a short name to the distributed node
+  --cookie \"cookie\" Sets a cookie for this distributed node
+  --hidden          Makes a hidden node
+  --werl            Uses Erlang's Windows shell GUI (Windows only)
+  --detached        Starts the Erlang VM detached from console
+  --remsh \"name\"    Connects to a node using a remote shell
+  --dot-iex \"path\"  Overrides default .iex.exs file and uses path instead;
+                    path can be empty, then no file will be loaded
 
 ** Options marked with (*) can be given more than once
 ** Options given after the .exs file or -- are passed down to the executed code
@@ -45,4 +39,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,46 +1,4 @@
 @if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
-setlocal
-if /I ""%1""==""--help"" goto documentation
-if /I ""%1""==""-h""     goto documentation
-if /I ""%1""==""/h""     goto documentation
-if    ""%1""==""/?""     goto documentation
-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.
-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.
-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
-echo ** Options can be passed to the Erlang VM using ELIXIR_ERL_OPTIONS or --erl
-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% %*
-:end
-endlocal
+call "%~dp0\elixir.bat" +iex --erl "-user Elixir.IEx.CLI" --no-halt %__ELIXIR_IEX_FLAGS% %*
+@set __ELIXIR_IEX_FLAGS=

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

@@ -35,14 +35,13 @@ defmodule EEx do
 
   ## Options
 
-  All functions in this module accept EEx-related options.
+  All functions in this module accepts EEx-related options.
   They are:
 
     * `:line` - the line to be used as the template start. Defaults to 1.
     * `:file` - the file to be used in the template. Defaults to the given
       file the template is read from or to "nofile" when compiling from a string.
     * `:engine` - the EEx engine to be used for compilation.
-    * `:trim` - trims whitespace left/right of quotation tags
 
   ## Engine
 
@@ -65,7 +64,7 @@ defmodule EEx do
   **must** use the equals sign (`=`). Since everything in
   Elixir is an expression, there are no exceptions for this rule.
   For example, while some template languages would special-case
-  `if/2` clauses, they are treated the same in EEx and
+  `if` clauses, they are treated the same in EEx and
   also require `=` in order to have their result printed:
 
       <%= if true do %>
@@ -90,7 +89,7 @@ defmodule EEx do
 
       <%= {:ok, v} = Access.fetch(assigns, :foo); v %>
 
-  The `assigns` extension is useful when the number of variables
+  The assigns extension is useful when the number of variables
   required by the template is not specified at compilation time.
   """
 
@@ -111,7 +110,7 @@ defmodule EEx do
 
   """
   defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
-    quote bind_quoted: binding() 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
       compiled = EEx.compile_string(source, info)
@@ -148,7 +147,7 @@ defmodule EEx do
 
   """
   defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
-    quote bind_quoted: binding() 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
       compiled = EEx.compile_file(file, info)
@@ -166,8 +165,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
 
@@ -175,8 +173,7 @@ 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
+  def compile_file(filename, options \\ []) do
     options = Keyword.merge options, [file: filename, line: 1]
     compile_string(File.read!(filename), options)
   end
@@ -190,9 +187,7 @@ defmodule EEx do
       "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
@@ -209,9 +204,7 @@ 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
+  def eval_file(filename, bindings \\ [], options \\ []) do
     options  = Keyword.put options, :file, filename
     compiled = compile_file(filename, options)
     do_eval(compiled, bindings, options)

lib/eex/lib/eex/compiler.ex

@@ -9,78 +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)
+        generate_buffer(tokens, "", [], 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
+  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)
-    generate_buffer(rest, state.engine.handle_begin(buffer), [wrapped | scope], %{state | line: line})
+    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([{: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])
     buffer = insert_quoted(tuples, state.quoted)
-    {buffer, rest}
+    {buffer, t}
   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
-  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
+  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], state) do
+    raise EEx.SyntaxError, message: "unexpected token #{inspect chars}", file: state.file, line: line
   end
 
   defp generate_buffer([], buffer, [], state) do
@@ -97,25 +74,23 @@ defmodule EEx.Compiler do
   defp wrap_expr(current, line, buffer, chars, state) do
     new_lines = List.duplicate(?\n, line - state.line)
     key = length(state.quoted)
-    placeholder = '__EEX__(' ++ Integer.to_charlist(key) ++ ');'
+    placeholder = '__EEX__(' ++ Integer.to_char_list(key) ++ ');'
     {current ++ placeholder ++ new_lines ++ chars,
-     %{state | quoted: [{key, state.engine.handle_end(buffer)} | state.quoted]}}
+     %{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

lib/eex/lib/eex/engine.ex

@@ -2,26 +2,17 @@ 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.
+    * `handle_body(quoted)` - receives the final built quoted
+      expression, should do final post-processing and return a
+      quoted expression.
 
-    * `handle_body(state)` - receives the state of the document
-      and it must 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 `"="`
@@ -34,34 +25,17 @@ 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 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
     quote do
       @behaviour EEx.Engine
 
-      def init(opts) 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
@@ -72,7 +46,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]
     end
   end
 
@@ -91,7 +65,6 @@ 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))
@@ -101,42 +74,21 @@ defmodule EEx.Engine do
   end
 
   @doc false
-  # TODO: Raise on 2.0
-  @spec fetch_assign!(Access.t, Access.key) :: term | nil
+  # TODO: raise on 1.3 or 1.4
   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.write :stderr, "warning: assign @#{key} not available in eex template. " <>
+                          "Please ensure all assigns are given as options. " <>
+                          "Available assigns: #{inspect keys}\n" <>
+                          Exception.format_stacktrace
         nil
     end
   end
 
-  @doc """
-  Returns an empty string as initial buffer.
-  """
-  def init(_opts) 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.
   """
@@ -159,6 +111,7 @@ defmodule EEx.Engine do
 
   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)

lib/eex/lib/eex/tokenizer.ex

@@ -1,39 +1,31 @@
 defmodule EEx.Tokenizer do
   @moduledoc false
 
-  @type content :: IO.chardata
-  @type line :: non_neg_integer
-  @type token :: {:text, content} |
-                 {:expr | :start_expr | :middle_expr | :end_expr, line, '=' | '', content}
-
   @doc """
-  Tokenizes the given charlist or binary.
+  Tokenizes the given char list 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
-    tokenize(String.to_charlist(bin), line, opts)
+  def tokenize(bin, line, opts) when is_binary(bin) do
+    tokenize(String.to_char_list(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
@@ -60,11 +52,11 @@ defmodule EEx.Tokenizer do
   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
+  defp tokenize([h|t], line, opts, buffer, acc) do
+    tokenize t, line, opts, [h|buffer], acc
   end
 
   defp tokenize([], _line, _opts, buffer, acc) do
@@ -83,16 +75,16 @@ defmodule EEx.Tokenizer do
 
   # Tokenize an expression until we find %>
 
-  defp expr([?%, ?> | t], line, buffer) do
+  defp expr([?%, ?>|t], line, buffer) do
     {:ok, buffer, line, t}
   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]
+  defp expr([h|t], line, buffer) do
+    expr t, line, [h|buffer]
   end
 
   defp expr([], line, _buffer) do
@@ -106,11 +98,11 @@ defmodule EEx.Tokenizer do
   # Middle tokens are marked with "->" or keywords
   # End tokens contain only the end word and optionally ")"
 
-  defp token_name([h | t]) when h in [?\s, ?\t, ?)] do
+  defp token_name([h|t]) when h in [?\s, ?\t, ?)] do
     token_name(t)
   end
 
-  defp token_name('od' ++ [h | _]) when h in [?\s, ?\t, ?)] do
+  defp token_name('od' ++ [h|_]) when h in [?\s, ?\t, ?)] do
     :start_expr
   end
 
@@ -151,7 +143,7 @@ defmodule EEx.Tokenizer do
     Enum.find_index tokens, fn
       {:fn_paren, _} -> true
       {:fn, _}       -> true
-      _              -> false
+      _                -> false
     end
   end
 
@@ -181,6 +173,7 @@ 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
@@ -197,7 +190,7 @@ defmodule EEx.Tokenizer do
 
   defp trim_left(buffer, acc) do
     case {trim_whitespace(buffer), acc} do
-      {[?\n | _] = trimmed_buffer, _} -> {true, trimmed_buffer}
+      {[?\n|_] = trimmed_buffer, _} -> {true, trimmed_buffer}
       {[], []} -> {true, []}
       _ -> {false, buffer}
     end
@@ -205,14 +198,14 @@ defmodule EEx.Tokenizer do
 
   defp trim_right(rest, line) do
     case trim_whitespace(rest) do
-      [?\r, ?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
-      [?\n | trimmed_rest] -> {true, trimmed_rest, line + 1}
+      [?\r, ?\n|trimmed_rest] -> {true, trimmed_rest, line + 1}
+      [?\n|trimmed_rest] -> {true, trimmed_rest, line + 1}
       [] -> {true, [], line}
       _ -> {false, rest, line}
     end
   end
 
-  defp trim_whitespace([h | t]) when h == ?\s or h == ?\t do
+  defp trim_whitespace([h|t]) when h == ?\s or h == ?\t do
     trim_whitespace(t)
   end
 

lib/eex/mix.exs

@@ -2,10 +2,8 @@ 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,8 +1,7 @@
 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
 
   test "evaluates simple string" do
     assert_eval "foo bar", "foo bar"
@@ -16,18 +15,11 @@ defmodule EEx.SmartEngineTest do
     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)
-    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 %>"
   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} ->
@@ -38,7 +30,7 @@ defmodule EEx.SmartEngineTest do
   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

@@ -158,6 +158,5 @@ baz %>
 
   test "raise syntax error when there is start mark and no end mark" do
     assert T.tokenize('foo <% :bar', 1) == {:error, 1, "missing token '%>'"}
-    assert T.tokenize('<%# true ', 1) == {:error, 1, "missing token '%>'"}
   end
 end

lib/eex/test/eex_test.exs

@@ -4,7 +4,7 @@ require EEx
 
 defmodule EExTest.Compiled do
   def before_compile do
-    fill_in_stacktrace()
+    fill_in_stacktrace
     {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
@@ -19,13 +19,13 @@ defmodule EExTest.Compiled do
   def file_sample(arg), do: private_file_sample(arg)
 
   def after_compile do
-    fill_in_stacktrace()
+    fill_in_stacktrace
     {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
   @file "unknown"
   def unknown do
-    fill_in_stacktrace()
+    fill_in_stacktrace
     {__ENV__.line, hd(tl(System.stacktrace))}
   end
 
@@ -53,422 +53,364 @@ 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
-      """
-      assert_eval "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n", template
-    end
+  test "evaluates with embedded" do
+    assert_eval "foo bar", "foo <%= :bar %>"
+  end
 
-    test "trim mode" do
-      string = "<%= 123 %> \n456\n  <%= 789 %>"
-      expected = "123456\n789"
-      assert_eval expected, string, [], trim: true
-    end
+  test "evaluates with embedded and the binding" do
+    assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
+  end
 
-    test "trim mode with middle expression" do
-      string = """
-      <%= cond do %>
-      <% false -> %>
-        this
-      <% true -> %>
-        that
-      <% end %>
-      """
-      expected = "  that\n"
-      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 "embedded code" do
-      assert_eval "foo bar", "foo <%= :bar %>"
-    end
+  test "evaluates with embedded do end and eval the expression" do
+    assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
+  end
 
-    test "embedded code with binding" do
-      assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
-    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 with do end when true" do
-      assert_eval "foo bar", "foo <%= if true do %>bar<% end %>"
-    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 do end when false" do
-      assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
-    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 and expression" 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 and multiple 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 "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 middle expression" do
-      assert_eval "foo bar", "foo <%= if true do %>bar<% else %>baz<% 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 evaluated middle expression" do
-      assert_eval "foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>"
-    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
 
-    test "embedded code with nested do end" do
-      assert_eval "foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>"
-    end
+  test "evaluates with defined variable" do
+    assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
+  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 "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 parentheses after end in end token" do
-      assert_eval " 101  102  103 ", "<%= Enum.map([1, 2, 3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
-    end
+  test "evaluates with end of token" do
+    assert_eval "foo bar %>", "foo bar %>"
+  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 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
-      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
-
-    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 %>\"]
+  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 "\ndone\n", string, packages: nil, all: nil
+    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"
+  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
-      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
-
-    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 "defined from string" do
+    assert EExTest.Compiled.string_sample(1, 2) == "3"
+  end
 
-    test "from string" do
-      assert EExTest.Compiled.string_sample(1, 2) == "3"
-    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" 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 "from file does 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]
-         }
+  test "defined from file do not affect backtrace" do
+    assert EExTest.Compiled.before_compile ==
+      {8,
+        {EExTest.Compiled,
+          :before_compile,
+          0,
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.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 ==
+      {23,
+        {EExTest.Compiled,
+          :after_compile,
+          0,
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 22]
        }
+     }
 
-      assert EExTest.Compiled.unknown ==
-        {29,
-          {EExTest.Compiled,
-            :unknown,
-            0,
-            [file: 'unknown', line: 28]
-         }
+    assert EExTest.Compiled.unknown ==
+      {29,
+        {EExTest.Compiled,
+          :unknown,
+          0,
+          [file: 'unknown', line: 28]
        }
-    end
+     }
   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)})"
+      EEx.Engine.handle_text(buffer, text)
     end
 
-    def handle_expr(buffer, "=", expr) do
-      buffer <> ":EQUAL(#{Macro.to_string(expr)})"
+    def handle_expr(buffer, mark, expr) do
+      EEx.Engine.handle_expr(buffer, mark, expr)
     end
   end
 
-  describe "custom engines" do
-    test "text" do
-      assert_eval "BODY(INIT:TEXT(foo))", "foo", [], 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 "calls handle_body" do
+    assert {:wrapped, "foo"} = EEx.eval_string("foo", [], engine: TestEngine)
   end
 
   defp assert_eval(expected, actual, binding \\ [], opts \\ []) do
@@ -476,8 +418,4 @@ defmodule EExTest do
     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/lib/access.ex

@@ -1,6 +1,6 @@
 defmodule Access do
   @moduledoc """
-  Key-based access to data structures using the `data[key]` syntax.
+  Key-based access to data structures via the `foo[bar]` syntax.
 
   Elixir provides two syntaxes for accessing values. `user[:name]`
   is used by dynamic structures, like maps and keywords, while
@@ -8,16 +8,9 @@ defmodule Access do
   `user[:name]` won't raise if the key `:name` is missing but
   `user.name` will raise if there is no `:name` key.
 
-  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-based lookups
 
-  ## Dynamic lookups
-
-  Out of the box, `Access` works with `Keyword` and `Map`:
+  Out of the box, Access works with `Keyword` and `Map`:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:a]
@@ -31,10 +24,7 @@ defmodule Access do
       iex> star_ratings[1.5]
       "★☆"
 
-  Note that the dynamic lookup syntax (`term[key]`) roughly translates to
-  `Access.get(term, key, nil)`.
-
-  `Access` can be combined with `Kernel.put_in/3` to put a value
+  Access can be combined with `Kernel.put_in/3` to put a value
   in a given key:
 
       iex> map = %{a: 1, b: 2}
@@ -47,50 +37,47 @@ defmodule Access do
       iex> put_in users["john"][:age], 28
       %{"john" => %{age: 28}, "meg" => %{age: 23}}
 
-  Furthermore, `Access` transparently ignores `nil` values:
+  Furthermore, Access transparently ignores `nil` values:
 
       iex> keywords = [a: 1, b: 2]
       iex> keywords[:c][:unknown]
       nil
 
-  Since `Access` is a behaviour, it can be implemented for key-value
+  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 accessed. `Access` requires the
+  module that defines the struct being access. Access requires the
   key comparison to be implemented using the `===` operator.
 
-  ## Static lookups
+  ## Field-based lookups
 
-  The `Access` syntax (`data[key]`) cannot be used to access fields in
-  structs, since structs do not implement the `Access` behaviour by
-  default. It is also a 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 (where fields are
-  known and not dynamic).
+  The Access syntax (`foo[bar]`) cannot be used to access fields in
+  structs. That's by design, as Access is meant to be used for
+  dynamic key-value structures, like maps and keywords, and not
+  by static ones like structs.
 
-  Therefore Elixir provides a static lookup for struct fields and for atom
-  fields in maps. Imagine a struct named `User` with a `:name` field.
-  The following would raise:
+  However Elixir already provides a field-based lookup for structs.
+  Imagine a struct named `User` with name and age fields. 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)
 
-  Structs instead 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`
-  for updating structs fields:
+  to for updating structs fields:
 
-      put_in user.name, "Mary"
-      #=> %User{name: "Mary"}
+      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.
-
-  As mentioned above, this works for atom keys in maps as well. Refer to the
-  `Map` module for more information on this.
+  Differently from `user[:name]`, `user.name` cannot be extended by
+  the developers, and will be always restricted to only maps and
+  structs.
 
   Summing up:
 
@@ -99,146 +86,21 @@ defmodule Access do
     * `user.name` is used by static structures, it is not extensible
       and it will raise on missing keys
 
-  ## Accessors
-
-  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.
-
-  For instance, given a user map with `: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
-      %{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.
-
-  ## Implementing the Access behaviour for custom data structures
-
-  In order to be able to use the `Access` behaviour with custom data structures
-  (which have to be structs), such structures have to implement the `Access`
-  behaviour. For example, for a `User` struct, this would have to be done:
-
-      defmodule User do
-        defstruct [:name, :email]
-
-        @behaviour Access
-        # Implementation of the Access callbacks...
-      end
-
   """
 
-  @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})
-
-  @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 stored under `key` in the given term `term`,
-  defaulting to `default` if not present.
-
-  This function should return the value under `key` in `term` if there's
-  such key, otherwise `default`.
-
-  For most data structures, this can be implemented using `fetch/2` internally;
-  for example:
-
-      def get(structure, key, default) do
-        case fetch(structure, key) do
-          {:ok, value} -> value
-          :error       -> default
-        end
-      end
-
-  See the `Map.get/3` and `Keyword.get/3` implementations for examples of
-  how to implement this callback.
-  """
-  @callback get(term :: t, key, default :: value) :: value
-
-  @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
+  @callback fetch(t, key) :: {:ok, value} | :error
+  @callback get_and_update(t, key, (value -> {value, value})) :: {value, t}
 
   defmacrop raise_undefined_behaviour(e, struct, top) do
     quote do
       stacktrace = System.stacktrace
       e =
         case stacktrace do
-          [unquote(top) | _] ->
+          [unquote(top)|_] ->
             %{unquote(e) | reason: "#{inspect unquote(struct)} does not implement the Access behaviour"}
           _ ->
             unquote(e)
@@ -248,33 +110,25 @@ defmodule Access do
   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.
+  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(%struct{} = container, key) do
+  def fetch(%{__struct__: struct} = container, key) do
     struct.fetch(container, key)
   rescue
     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
@@ -289,67 +143,28 @@ 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.
+  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)
-
-  def get(%{__struct__: struct} = container, key, default) do
-    try do
-      struct.fetch(container, key)
-    rescue
-      e in UndefinedFunctionError ->
-        raise_undefined_behaviour e, struct, {^struct, :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.
+  The argument function `fun` must receive the value for the given `key` (or
+  `nil` if the key doesn't exist in `container`). It must return a tuple
+  containing the `get` value and the new value to be stored in the `container`.
 
-  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`.
+  This function returns a two-element tuple.
+  The first element is the `get` value, as returned by `fun`.
+  The second element is the container, updated with the value returned by `fun`.
   """
-  @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, term, (term -> {get, term})) :: {get, t} when get: var
   def get_and_update(container, key, fun)
 
   def get_and_update(%{__struct__: struct} = container, key, fun) do
@@ -359,8 +174,14 @@ defmodule Access do
       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
-    Map.get_and_update(map, key, fun)
+  def get_and_update(%{} = map, key, fun) do
+    current_value = case :maps.find(key, map) do
+      {:ok, value} -> value
+      :error -> nil
+    end
+
+    {get, update} = fun.(current_value)
+    {get, :maps.put(key, update, map)}
   end
 
   def get_and_update(list, key, fun) when is_list(list) do
@@ -371,333 +192,4 @@ defmodule Access do
     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(%{__struct__: struct} = container, key) do
-    struct.pop(container, key)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :pop, [^container, ^key], _}
-  end
-
-  def pop(map, key) when is_map(map) do
-    Map.pop(map, key)
-  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"
-  end
-
-  ## Accessors
-
-  @doc """
-  Returns a function that 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, %{}), Access.key(:name)])
-      nil
-
-  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"}}
-
-  ## Examples
-
-      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
-
-      iex> get_in([], [Access.key(:foo)])
-      ** (BadMapError) expected a map, 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))
-      :get_and_update, data, next ->
-        value = Map.get(data, key, default)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-    end
-  end
-
-  @doc """
-  Returns a function that 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 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)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
-      {"john", %{user: %{}}}
-      iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])
-      ** (KeyError) key :unknown not found in: %{name: \"john\"}
-
-  An error is raised if the accessed structure is not a map/struct:
-
-      iex> get_in([], [Access.key!(:foo)])
-      ** (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}"
-    end
-  end
-
-  @doc ~S"""
-  Returns a function that 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.
-
-  ## 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)}
-      ...> end)
-      {"john", %{user: {"JOHN", 27}}}
-      iex> pop_in(map, [:user, Access.elem(0)])
-      ** (RuntimeError) cannot pop data from a tuple
-
-  An error is raised if the accessed structure is not a tuple:
-
-      iex> get_in(%{}, [Access.elem(0)])
-      ** (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) 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}"
-    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.
-
-  ## 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)}
-      ...> 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:
-
-      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}
-      ...> end)
-      {[1, 2, 3, 4, 5], [2, 6, 10]}
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.all()])
-      ** (RuntimeError) Access.all/0 expected a list, got: %{}
-
-  """
-  @spec all() :: access_fun(data :: list, get_value :: list)
-  def all() do
-    &all/3
-  end
-
-  defp all(:get, data, next) when is_list(data) do
-    Enum.map(data, next)
-  end
-
-  defp all(:get_and_update, data, next) when is_list(data) do
-    all(data, next, _gets = [], _updates = [])
-  end
-
-  defp all(_op, data, _next) do
-    raise "Access.all/0 expected a list, got: #{inspect data}"
-  end
-
-  defp all([head | rest], next, gets, updates) do
-    case next.(head) do
-      {get, update} -> all(rest, next, [get | gets], [update | updates])
-      :pop -> all(rest, next, [head | gets], updates)
-    end
-  end
-
-  defp all([], _next, gets, updates) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
-  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.
-
-  ## 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)}
-      ...> 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"}]}
-
-  When the index is out of bounds, `nil` is returned and the update function is never called:
-
-      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)}
-      ...> end)
-      {nil, [%{name: "john"}, %{name: "mary"}]}
-
-  An error is raised for negative indexes:
-
-      iex> get_in([], [Access.at(-1)])
-      ** (FunctionClauseError) no function clause matching in Access.at/1
-
-  An error is raised if the accessed structure is not a list:
-
-      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
-  end
-
-  defp at(:get, data, index, next) when is_list(data) do
-    data |> Enum.at(index) |> next.()
-  end
-
-  defp at(:get_and_update, data, index, next) when is_list(data) do
-    get_and_update_at(data, index, next, [])
-  end
-
-  defp at(_op, data, _index, _next) do
-    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)}
-    end
-  end
-
-  defp get_and_update_at([head | rest], index, next, updates) do
-    get_and_update_at(rest, index - 1, next, [head | updates])
-  end
-
-  defp get_and_update_at([], _index, _next, updates) do
-    {nil, :lists.reverse(updates)}
-  end
 end

lib/elixir/lib/agent.ex

@@ -6,18 +6,16 @@ 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
           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 id, defauts 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,41 +117,13 @@ defmodule Agent do
   @typedoc "The agent state"
   @type state :: term
 
-  @doc false
-  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
-      spec = [
-        id: opts[:id] || __MODULE__,
-        start: Macro.escape(opts[:start]) || quote(do: {__MODULE__, :start_link, [arg]}),
-        restart: opts[:restart] || :permanent,
-        shutdown: opts[:shutdown] || 5000,
-        type: :worker
-      ]
-
-      @doc false
-      def child_spec(arg) do
-        %{unquote_splicing(spec)}
-      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
@@ -194,22 +144,12 @@ 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
   def start_link(fun, options \\ []) when is_function(fun, 0) do
@@ -217,11 +157,11 @@ defmodule Agent do
   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
   def start_link(module, fun, args, options \\ []) do
@@ -232,13 +172,6 @@ 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
   def start(fun, options \\ []) when is_function(fun, 0) do
@@ -246,9 +179,10 @@ defmodule Agent do
   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
   def start(module, fun, args, options \\ []) do
@@ -256,24 +190,13 @@ defmodule Agent do
   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
@@ -283,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
@@ -293,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
@@ -322,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
@@ -334,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
@@ -363,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
@@ -375,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
@@ -390,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
@@ -402,25 +295,25 @@ 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)
+    if is_integer(reason) or reason == :infinity do
+      IO.write :stderr, "warning: Agent.stop(agent, timeout) is deprecated, " <>
+                        "please use Agent.stop(agent, :normal, timeout) instead\n" <>
+                        Exception.format_stacktrace
+      :gen.stop(agent, :normal, reason)
+    else
+      :gen.stop(agent, reason, timeout)
+    end
   end
 end

lib/elixir/lib/application.ex

@@ -9,64 +9,24 @@ defmodule Application do
   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. In Elixir, the Mix build tool is responsible for compiling your
-  source code and generating your application `.app` file. You can learn more
-  about the generation of `.app` files by typing `mix help compile.app`.
+  application.
 
-  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.
+  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.
 
-  Starting an application is done via the "application module callback", which
-  is a module that defines the `start/2` function. The `start/2` function should
-  then start a supervisor, which is often called as the top-level supervisor, since
-  it sits at the root of a potentially long supervision tree. When the system is
-  shutting down, all applications shut down their top-level supervisor, which
-  terminates children in the opposite order they are started.
-
-  We have mentioned the Mix build tool is responsible for compiling applications,
-  but it is also capable of running applications. For example, `mix test`
-  automatically starts your application dependencies and your application itself
-  before your test runs. `mix run --no-halt` also 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.
-
-  Shutting down a live system cleanly can be done by calling `System.stop/1`.
-  It will shut down all applications in the opposite order they are started.
-  Each application will then shutdown its top-level supervisor, if one is
-  available, which then shuts down its children.
-
-  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.
-
-  Applications also provide an "application environment", which is how
-  applications are configured. The application environment can either be set
-  statically, via a configuration file, or dynamically via `put_env/3` and
-  friends.
-
-  Over the next sections, we will cover the "application environment" and
-  the "application module callback" in more detail.
+  You can learn more about Mix generation of `.app` files by typing
+  `mix help compile.app`.
 
   ## Application environment
 
   Once an application is started, OTP provides an application environment
   that can be used to configure the application.
 
-  Assuming you are inside a Mix project, you can edit the `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
@@ -80,13 +40,9 @@ defmodule Application do
       Application.get_env(:APP_NAME, :hello)
       #=> :world
 
-  Applications and dependencies in Mix projects are typically configured
-  via the `config/config.exs` file. For example, someone using your
-  application can configure the `:hello` key as follows:
-
-      config :APP_NAME, hello: :brand_new_world
-
-  It is also possible to configure applications dynamically via `put_env/3`.
+  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).
 
   Keep in mind that each application is responsible for its environment.
   Do not use the functions in this module for directly accessing or modifying
@@ -122,8 +78,8 @@ defmodule Application do
 
   The `type` argument passed to `start/2` is usually `:normal` unless in a
   distributed setup where application takeovers and failovers are configured.
-  Distributed applications is beyond the scope of this documentation. For those
-  interested on the topic, please access the OTP documentation:
+  This particular aspect of applications is explained in more detail in the
+  OTP documentation:
 
     * [`:application` module](http://www.erlang.org/doc/man/application.html)
     * [Applications – OTP Design Principles](http://www.erlang.org/doc/design_principles/applications.html)
@@ -132,101 +88,25 @@ defmodule Application do
   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.
-
-  An application without a supervision tree doesn't define an application
-  module callback in the application definition in `mix.exs` file. Even though
-  there is no module with application callbacks such as `start/2` and
-  `stop/1`, the application can be started and stopped the same way as an
-  application with a supervision tree.
   """
 
-  @doc """
-  Called when an application is started.
-
-  This function is called when an 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
-  application's supervision tree if the application follows the OTP design
-  principles around supervision).
-
-  `start_type` defines how the application is started:
-
-    * `: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`
-      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`.
-    * `{:failover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on node `node`, and the
-      application specification key `:start_phases` is not `:undefined`.
-
-  `start_args` are the arguments passed to the application in the `:mod`
-  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`
-  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).
-
-  `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}
-
-  @doc """
-  Called when an application is stopped.
-
-  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
-  `start/2` callback did, and should perform any necessary cleanup. The return
-  value of this callback is ignored.
-
-  `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
-
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour Application
+      @behaviour :application
 
       @doc false
       def stop(_state) do
         :ok
       end
 
-      defoverridable Application
+      defoverridable [stop: 1]
     end
   end
 
   @type app :: atom
   @type key :: atom
   @type value :: term
-  @type state :: term
   @type start_type :: :permanent | :transient | :temporary
 
   @application_keys [:description, :id, :vsn, :modules, :maxP, :maxT, :registered,
@@ -266,7 +146,7 @@ defmodule Application do
   end
 
   @doc """
-  Gets the application for the given module.
+  Get the application for the given module.
 
   The application is located by analyzing the spec
   of all loaded applications. Returns `nil` if
@@ -333,7 +213,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
@@ -398,7 +278,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:
@@ -483,7 +363,7 @@ 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
   def app_dir(app) when is_atom(app) do
@@ -496,13 +376,10 @@ defmodule Application do
   @doc """
   Returns the given path inside `app_dir/1`.
   """
-  @spec app_dir(app, String.t | [String.t]) :: String.t
+  @spec app_dir(app, 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
 
   @doc """
   Returns a list with information about the applications which are currently running.
@@ -528,9 +405,9 @@ defmodule Application do
   @spec format_error(any) :: String.t
   def format_error(reason) do
     try do
-      do_format_error(reason)
+      impl_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)
@@ -538,68 +415,68 @@ defmodule Application do
   end
 
   # exit(:normal) call is special cased, undo the special case.
-  defp do_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
+  defp impl_format_error({{:EXIT, :normal}, {mod, :start, args}}) do
     Exception.format_exit({:normal, {mod, :start, args}})
   end
 
   # {:error, reason} return value
-  defp do_format_error({reason, {mod, :start, args}}) do
+  defp impl_format_error({reason, {mod, :start, args}}) do
     Exception.format_mfa(mod, :start, args) <> " returned an error: " <>
       Exception.format_exit(reason)
   end
 
   # error or exit(reason) call, use exit reason as reason.
-  defp do_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
+  defp impl_format_error({:bad_return, {{mod, :start, args}, {:EXIT, reason}}}) do
     Exception.format_exit({reason, {mod, :start, args}})
   end
 
   # bad return value
-  defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
+  defp impl_format_error({:bad_return, {{mod, :start, args}, return}}) do
     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
+  defp impl_format_error({:already_started, app}) when is_atom(app) do
     "already started application #{app}"
   end
 
-  defp do_format_error({:not_started, app}) when is_atom(app) do
+  defp impl_format_error({:not_started, app}) when is_atom(app) do
     "not started application #{app}"
   end
 
-  defp do_format_error({:bad_application, app}) do
+  defp impl_format_error({:bad_application, app}) do
     "bad application: #{inspect(app)}"
   end
 
-  defp do_format_error({:already_loaded, app}) when is_atom(app) do
+  defp impl_format_error({:already_loaded, app}) when is_atom(app) do
     "already loaded application #{app}"
   end
 
-  defp do_format_error({:not_loaded, app}) when is_atom(app) do
+  defp impl_format_error({:not_loaded, app}) when is_atom(app) do
     "not loaded application #{app}"
   end
 
-  defp do_format_error({:invalid_restart_type, restart}) do
+  defp impl_format_error({:invalid_restart_type, restart}) do
     "invalid application restart type: #{inspect(restart)}"
   end
 
-  defp do_format_error({:invalid_name, name}) do
+  defp impl_format_error({:invalid_name, name}) do
     "invalid application name: #{inspect(name)}"
   end
 
-  defp do_format_error({:invalid_options, opts}) do
+  defp impl_format_error({:invalid_options, opts}) do
     "invalid application options: #{inspect(opts)}"
   end
 
-  defp do_format_error({:badstartspec, spec}) do
+  defp impl_format_error({:badstartspec, spec}) do
     "bad application start specs: #{inspect(spec)}"
   end
 
-  defp do_format_error({'no such file or directory', file}) do
+  defp impl_format_error({'no such file or directory', file}) do
     "could not find application file: #{file}"
   end
 
-  defp do_format_error(reason) do
+  defp impl_format_error(reason) do
     Exception.format_exit(reason)
   end
 end

lib/elixir/lib/atom.ex

@@ -22,24 +22,18 @@ defmodule Atom do
   end
 
   @doc """
-  Converts an atom to a charlist.
+  Converts an atom to a char list.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Atom.to_charlist(:"An atom")
+      iex> Atom.to_char_list(:"An atom")
       'An atom'
 
   """
-  @spec to_charlist(atom) :: charlist
-  def to_charlist(atom) do
+  @spec to_char_list(atom) :: char_list
+  def to_char_list(atom) do
     :erlang.atom_to_list(atom)
   end
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(atom) :: charlist
-  def to_char_list(atom), do: Atom.to_charlist(atom)
 end

lib/elixir/lib/behaviour.ex

@@ -2,14 +2,14 @@ defmodule Behaviour do
   @moduledoc """
   This module has been 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)`.
   """
 
+  # TODO: Deprecate by 1.2
+  # TODO: Remove by 2.0
+
   @doc """
   Defines a function callback according to the given type specification.
   """
@@ -80,12 +80,6 @@ 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)

lib/elixir/lib/bitwise.ex

@@ -1,35 +1,30 @@
 defmodule Bitwise do
   @moduledoc """
-  A set of macros that perform calculations on bits.
+  This module provides macro-based operators that perform calculations
+  on (sets of) bits.
 
-  The macros in this module come in two flavors: named or
-  operators. For example:
+  In general, you should `use` the Bitwise module as a whole:
 
       iex> use Bitwise
-      iex> bnot 1   # named
+      iex> bnot 1
       -2
-      iex> 1 &&& 1  # operator
+      iex> 1 &&& 1
       1
 
-  If you prefer to use only operators or skip them, you can
-  pass the following options:
+  When used, it accepts the following options:
 
-    * `:only_operators` - includes only operators
-    * `:skip_operators` - skips operators
-
-  For example:
+    * `:only_operators` - include only operators
+    * `:skip_operators` - skip operators
 
       iex> use Bitwise, only_operators: true
       iex> 1 &&& 1
       1
 
-  When invoked with no options, `use Bitwise` is equivalent
-  to `import Bitwise`.
 
-  All bitwise macros can be used in guards:
+  These 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
 
@@ -42,8 +37,7 @@ defmodule Bitwise do
         [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
       Keyword.get(options, :skip_operators) ->
         [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
-      true ->
-        []
+      true -> []
     end
 
     quote do

lib/elixir/lib/calendar.ex

@@ -1,196 +0,0 @@
-defmodule Calendar do
-  @moduledoc """
-  This module defines the responsibilities for working with
-  calendars, dates, times and datetimes in Elixir.
-
-  Currently it defines types and the minimal implementation
-  for a calendar behaviour in Elixir. The goal of the Calendar
-  features in Elixir is to provide a base for interoperability
-  instead of full-featured datetime API.
-
-  For the actual date, time and datetime structures, see `Date`,
-  `Time`, `NaiveDateTime` and `DateTime`.
-
-  Note the year, month, day, etc. designations are overspecified
-  (i.e. an integer instead of `1..12` for months) because different
-  calendars may have a different number of days per month, months per year and so on.
-  """
-
-  @type year :: integer
-  @type month :: integer
-  @type day :: integer
-  @type hour :: integer
-  @type minute :: integer
-  @type second :: integer
-
-  @typedoc """
-  The internal time format is used when converting between calendars.
-
-  It represents time as a fraction of a day (starting from midnight).
-  `parts_in_day` specifies how much of the day is already passed,
-  while `parts_per_day` signifies how many parts there fit in a day.
-  """
-  @type day_fraction :: {parts_in_day :: non_neg_integer, parts_per_day :: pos_integer}
-
-  @typedoc """
-  The internal date format that is used when converting between calendars.
-
-  This is the amount of days including the fractional part that has passed of
-  the last day since 0000-01-01+00:00T00:00.00000 in ISO 8601 notation (also
-  known as midnight 1 January BC 1 of the Proleptic Gregorian Calendar).
-
-  The `parts_per_day` represent how many subparts the current day is subdivided in
-  (for different calendars, picking a different `parts_per_day` might make sense).
-  The `parts_in_day` represents how many of these `parts_per_day` have passed in the
-  last day.
-  """
-  @type iso_days :: {days :: integer, day_fraction}
-
-  @typedoc """
-  Microseconds with stored precision.
-
-  The precision represents the number of digits that must be used when
-  representing the microseconds to external format. If the precision is 0,
-  it means microseconds must be skipped.
-  """
-  @type microsecond :: {0..999_999, 0..6}
-
-  @typedoc "A calendar implementation"
-  @type calendar :: module
-
-  @typedoc "The time zone ID according to the IANA tz database (e.g. Europe/Zurich)"
-  @type time_zone :: String.t
-
-  @typedoc "The time zone abbreviation (e.g. CET or CEST or BST etc.)"
-  @type zone_abbr :: String.t
-
-  @typedoc "The time zone UTC offset in seconds"
-  @type utc_offset :: integer
-
-  @typedoc "The time zone standard offset in seconds (not zero in summer times)"
-  @type std_offset :: integer
-
-  @typedoc "Any map/struct that contains the date fields"
-  @type date :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day}
-
-  @typedoc "Any map/struct that contains the time fields"
-  @type time :: %{optional(any) => any, hour: hour, minute: minute, second: second, microsecond: microsecond}
-
-  @typedoc "Any map/struct that contains the naive_datetime fields"
-  @type naive_datetime :: %{optional(any) => any, calendar: calendar, year: year, month: month, day: day,
-                            hour: hour, minute: minute, second: second, microsecond: microsecond}
-
-  @typedoc "Any map/struct that contains the datetime fields"
-  @type datetime :: %{optional(any) => any, 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}
-
-  @doc """
-  Returns how many days there are in the given year-month.
-  """
-  @callback days_in_month(year, month) :: day
-
-  @doc """
-  Returns true if the given year is a leap year.
-
-  A leap year is a year of a longer length than normal. The exact meaning
-  is up to the calendar. A calendar must return `false` if it does not support
-  the concept of leap years.
-  """
-  @callback leap_year?(year) :: boolean
-
-  @doc """
-  Calculates the day of the week from the given `year`, `month`, and `day`.
-  """
-  @callback day_of_week(year, month, day) :: non_neg_integer()
-
-  @doc """
-  Converts the date into a string according to the calendar.
-  """
-  @callback date_to_string(year, month, day) :: String.t
-
-  @doc """
-  Converts the datetime (without time zone) into a string according to the calendar.
-  """
-  @callback naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) :: String.t
-
-  @doc """
-  Converts the datetime (with time zone) into a string according to the calendar.
-  """
-  @callback datetime_to_string(year, month, day, hour, minute, second, microsecond,
-                               time_zone, zone_abbr, utc_offset, std_offset) :: String.t
-
-  @doc """
-  Converts the time into a string according to the calendar.
-  """
-  @callback time_to_string(hour, minute, second, microsecond) :: String.t
-
-  @doc """
-  Converts the given datetime (with time zone) into the `t:iso_days` format.
-  """
-  @callback naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) :: iso_days
-
-  @doc """
-  Converts `t:iso_days` to the Calendar's datetime format.
-  """
-  @callback naive_datetime_from_iso_days(iso_days) :: {year, month, day, hour, minute, second, microsecond}
-
-  @doc """
-  Converts the given time to the `t:day_fraction` format.
-  """
-  @callback time_to_day_fraction(hour, minute, second, microsecond) :: day_fraction
-
-  @doc """
-  Converts `t:day_fraction` to the Calendar's time format.
-  """
-  @callback time_from_day_fraction(day_fraction) :: {hour, minute, second, microsecond}
-
-  @doc """
-  Define the rollover moment for the given calendar.
-
-  This is the moment, in your calendar, when the current day ends
-  and the next day starts.
-
-  The result of this function is used to check if two calendars rollover at
-  the same time of day. If they do not, we can only convert datetimes and times
-  between them. If they do, this means that we can also convert dates as well
-  as naive datetimes between them.
-
-  This day fraction should be in its most simplified form possible, to make comparisons fast.
-
-  ## Examples
-
-    * If, in your Calendar, a new day starts at midnight, return {0, 1}.
-    * If, in your Calendar, a new day starts at sunrise, return {1, 4}.
-    * If, in your Calendar, a new day starts at noon, return {1, 2}.
-    * If, in your Calendar, a new day starts at sunset, return {3, 4}.
-
-  """
-  @callback day_rollover_relative_to_midnight_utc() :: day_fraction
-
-  @doc """
-  Should return `true` if the given date describes a proper date in the calendar.
-  """
-  @callback valid_date?(year, month, day) :: boolean
-
-  @doc """
-  Should return `true` if the given time describes a proper time in the calendar.
-  """
-  @callback valid_time?(hour, minute, second, microsecond) :: boolean
-
-  # General Helpers
-
-  @doc """
-  Returns `true` if two calendars have the same moment of starting a new day,
-  `false` otherwise.
-
-  If two calendars are not compatible, we can only convert datetimes and times
-  between them. If they are compatible, this means that we can also convert
-  dates as well as naive datetimes between them.
-  """
-  @spec compatible_calendars?(Calendar.calendar, Calendar.calendar) :: boolean
-  def compatible_calendars?(calendar, calendar), do: true
-  def compatible_calendars?(calendar1, calendar2) do
-    calendar1.day_rollover_relative_to_midnight_utc() == calendar2.day_rollover_relative_to_midnight_utc()
-  end
-end

lib/elixir/lib/calendar/date.ex

@@ -1,597 +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`
-  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 `==`, `>`, `<` 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 amount of days betweens instants. For example, if there
-  is an interest in computing the amount 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]>
-
-      iex> Date.range(~N[2000-01-01 09:00:00], ~D[1999-01-01])
-      #DateRange<~N[2000-01-01 09:00:00], ~D[1999-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
-  """
-
-  @spec range(Calendar.date, Calendar.date) :: Date.Range.t
-  def range(%{calendar: calendar} = first, %{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(%{calendar: _, year: _, month: _, day: _},
-            %{calendar: _, year: _, month: _, day: _}) 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
-
-  """
-  @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
-
-  """
-  @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
-
-  """
-  @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 """
-  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) :: {: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"
-
-  """
-  @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) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<year::4-bytes, ?-, month::2-bytes, ?-, day::2-bytes>>, calendar) do
-    with {year, ""} <- Integer.parse(year),
-         {month, ""} <- Integer.parse(month),
-         {day, ""} <- Integer.parse(day) do
-      with {:ok, date} <- new(year, month, day, Calendar.ISO),
-           do: convert(date, calendar)
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  def from_iso8601(<<_::binary>>, _calendar) do
-    {:error, :invalid_format}
-  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) :: 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) when format in [:basic, :extended] do
-    %{year: year, month: month, day: day} = convert!(date, Calendar.ISO)
-    Calendar.ISO.date_to_iso8601(year, month, day, format)
-  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) :: {: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) :: t
-  def from_erl!(tuple) do
-    case from_erl(tuple) 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
-
-  """
-  @spec compare(Calendar.date, Calendar.date) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar, year: year1, month: month1, day: day1},
-              %{calendar: calendar, year: year2, month: month2, day: day2}) do
-    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 it's 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}}
-
-  """
-  @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}
-
-  """
-  @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]
-
-  """
-  @spec add(Calendar.date, integer()) :: t
-  def add(%{calendar: calendar} = date, days) do
-    {iso_days_days, fraction} = to_iso_days(date)
-    from_iso_days({iso_days_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[2000-01-01], ~N[2000-01-03 09:00:00])
-      -2
-
-  """
-  @spec diff(Calendar.date, Calendar.date) :: integer
-  def diff(%{calendar: Calendar.ISO, year: year1, month: month1, day: day1},
-           %{calendar: Calendar.ISO, year: year2, month: month2, day: day2}) do
-    Calendar.ISO.date_to_iso_days_days(year1, month1, day1) -
-      Calendar.ISO.date_to_iso_days_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_days(year, month, day), {0, 86400000000}}
-  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(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
-
-  """
-  @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,86 +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: Calendar.days,
-                         last_in_iso_days: Calendar.days}
-
-  defstruct [:first, :last, :first_in_iso_days, :last_in_iso_days]
-
-  defimpl Enumerable do
-    def member?(%{first: %{calendar: calendar, year: first_year, month: first_month, day: first_day},
-                  last: %{calendar: calendar, year: last_year, month: last_month, day: last_day},
-                  first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days},
-                %Date{calendar: calendar, year: year, month: month, day: day}) do
-      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(%Date.Range{first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days}) do
-      {:ok, abs(first_in_iso_days - last_in_iso_days) + 1}
-    end
-
-    def reduce(%Date.Range{first_in_iso_days: first_in_iso_days, last_in_iso_days: last_in_iso_days,
-                           first: %{calendar: calendar}}, acc, fun) do
-      reduce(first_in_iso_days, last_in_iso_days, acc, fun, calendar, first_in_iso_days <= last_in_iso_days)
-    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_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_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(days, Calendar.ISO) do
-      {year, month, day} = Calendar.ISO.date_from_iso_days_days(days)
-      %Date{year: year, month: month, day: day, calendar: Calendar.ISO}
-    end
-
-    defp date_from_iso_days_days(days, calendar) do
-      {year, month, day, _, _, _, _} = calendar.naive_datetime_from_iso_days({days, {0, 86400000000}})
-      %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,670 +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 `==`, `>`, `<` 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
-  TimeZone 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(1464096368)
-      iex> datetime
-      #DateTime<2016-05-24 13:26:08Z>
-
-      iex> {:ok, datetime} = DateTime.from_unix(1432560368868569, :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(143256036886856, 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!(1464096368)
-      #DateTime<2016-05-24 13:26:08Z>
-
-      iex> DateTime.from_unix!(1432560368868569, :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>
-
-  """
-  @spec from_naive(NaiveDateTime.t, Calendar.time_zone) :: {:ok, t}
-  def from_naive(naive_datetime, time_zone)
-
-  def from_naive(%NaiveDateTime{calendar: calendar,
-                                hour: hour, minute: minute, second: second, microsecond: microsecond,
-                                year: year, month: month, day: day}, "Etc/UTC") do
-    {:ok, %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"}}
-  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>
-
-  """
-  @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> 1464096368 |> 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{calendar: calendar, year: year, month: month, day: day,
-                         hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    %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{year: year, month: month, day: day, calendar: calendar}) do
-    %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{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: calendar}) do
-    %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(_, format) when format not in [:extended, :basic] do
-    raise ArgumentError, "DateTime.to_iso8601/2 expects format to be :extended or :basic, got: #{inspect format}"
-  end
-
-  def to_iso8601(%{calendar: Calendar.ISO, 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}, format) do
-    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: _, year: _, month: _, day: _,
-                   hour: _, minute: _, second: _, microsecond: _,
-                   time_zone: _, zone_abbr: _, utc_offset: _, std_offset: _} = datetime, format) 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 ISO8601 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 ISO8601 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> 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}
-
-  """
-  @spec from_iso8601(String.t, Calendar.calendar) :: {:ok, t, Calendar.utc_offset} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<year::4-bytes, ?-, month::2-bytes, ?-, day::2-bytes, sep,
-                     hour::2-bytes, ?:, min::2-bytes, ?:, sec::2-bytes, rest::binary>>, calendar) when sep in [?\s, ?T] do
-    with {year, ""} <- Integer.parse(year),
-         {month, ""} <- Integer.parse(month),
-         {day, ""} <- Integer.parse(day),
-         {hour, ""} <- Integer.parse(hour),
-         {minute, ""} <- Integer.parse(min),
-         {second, ""} <- Integer.parse(sec),
-         {microsecond, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {:ok, date} <- Date.new(year, month, day),
-         {:ok, time} <- Time.new(hour, minute, second, microsecond),
-         {:ok, offset} <- parse_offset(rest) do
-      %{year: year, month: month, day: day} = date
-      %{hour: hour, minute: minute, second: second, microsecond: microsecond} = time
-      {_, 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}
-    else
-      {:error, reason} -> {:error, reason}
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  def from_iso8601(_, _) do
-    {:error, :invalid_format}
-  end
-
-  defp parse_offset(rest) do
-    case Calendar.ISO.parse_offset(rest) do
-      {offset, ""} when is_integer(offset) -> {:ok, offset}
-      {nil, ""} -> {:error, :missing_offset}
-      _ -> {: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"
-
-  """
-  @spec to_string(Calendar.datetime) :: String.t
-  def to_string(datetime)
-
-  def to_string(%{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}) do
-    calendar.datetime_to_string(year, month, day, hour, minute, second, microsecond,
-                                time_zone, zone_abbr, utc_offset, std_offset)
-  end
-
-  defimpl String.Chars do
-    def to_string(%{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}) do
-      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, 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}, _) do
-      "#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
-
-  @doc """
-  Compares two datetime structs.
-
-  Returns `:gt` if 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 stc 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
-
-  """
-  @spec compare(Calendar.datetime, Calendar.datetime) :: :lt | :eq | :gt
-  def compare(%DateTime{utc_offset: utc_offset1, std_offset: std_offset1} = datetime1,
-              %DateTime{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`.
-
-  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
-
-  """
-  @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 """
-  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"}}
-
-  """
-  @spec convert(Calendar.datetime, Calendar.calendar) :: {:ok, t} | {:error, :incompatible_calendars}
-  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
-    {:ok, %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}}
-  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"}
-
-  """
-  @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
-
-  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
-end

lib/elixir/lib/calendar/iso.ex

@@ -1,448 +0,0 @@
-defmodule Calendar.ISO do
-  @moduledoc """
-  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 ISO8601 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 62167219200
-  @unix_start 1_000_000 * -@unix_epoch
-  @unix_end 315569519999999999 - @unix_epoch * 1_000_000
-  @unix_range_microseconds @unix_start..@unix_end
-
-  @type year :: 0..9999
-  @type month :: 1..12
-  @type day :: 1..31
-
-  @seconds_per_minute 60
-  @seconds_per_hour 60 * 60
-  @seconds_per_day 24 * 60 * 60 # Note that this does _not_ handle leap seconds.
-  @microseconds_per_second 1_000_000
-
-  @doc """
-  Returns the `t:Calendar.iso_days` format of the specified 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}}
-
-  """
-  @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_days(year, month, day),
-     time_to_day_fraction(hour, minute, second, microsecond)}
-  end
-
-  @doc """
-  Converts the `t:Calendar.iso_days` 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({730485, {0, 86400}})
-      {2000, 1, 1, 0, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({730485, {43200, 86400}})
-      {2000, 1, 1, 12, 0, 0, {0, 6}}
-
-  """
-  @spec naive_datetime_from_iso_days(Calendar.iso_days) ::
-        {Calendar.year, Calendar.month, Calendar.day,
-         Calendar.hour, Calendar.minute, Calendar.second, Calendar.microsecond}
-  def naive_datetime_from_iso_days({days, day_fraction}) do
-    {year, month, day} = date_from_iso_days_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}
-
-  """
-  @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, 86400000000}
-  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, @seconds_per_day * @microseconds_per_second}
-  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}}
-
-  """
-  @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 * @seconds_per_day * @microseconds_per_second, 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
-  def date_to_iso_days_days(0, 1, 1) do
-    0
-  end
-  def date_to_iso_days_days(1970, 1, 1) do
-    719528
-  end
-  def date_to_iso_days_days(year, month, day) when year <= 9999 do
-    :calendar.date_to_gregorian_days(year, month, day)
-  end
-
-  # Converts count of days since 0000-01-01 to {year, month, day} tuple.
-  @doc false
-  def date_from_iso_days_days(days) when days <= 3652424 do
-    :calendar.gregorian_days_to_date(days)
-  end
-
-  defp div_mod(int1, int2) do
-    div = div(int1, int2)
-    mod = int1 - (div * int2)
-    {div, mod}
-  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
-
-  """
-  @spec days_in_month(year, month) :: 28..31
-  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 if the given year is a leap year.
-
-  ## Examples
-
-      iex> Calendar.ISO.leap_year?(2000)
-      true
-      iex> Calendar.ISO.leap_year?(2001)
-      false
-      iex> Calendar.ISO.leap_year?(2004)
-      true
-      iex> Calendar.ISO.leap_year?(1900)
-      false
-
-  """
-  @spec leap_year?(year) :: boolean()
-  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, 01)
-      2
-      iex> Calendar.ISO.day_of_week(2016, 11, 02)
-      3
-      iex> Calendar.ISO.day_of_week(2016, 11, 03)
-      4
-      iex> Calendar.ISO.day_of_week(2016, 11, 04)
-      5
-      iex> Calendar.ISO.day_of_week(2016, 11, 05)
-      6
-      iex> Calendar.ISO.day_of_week(2016, 11, 06)
-      7
-  """
-  @spec day_of_week(year, month, day) :: 1..7
-  def day_of_week(year, month, day)
-      when is_integer(year) and is_integer(month) and is_integer(day) do
-    :calendar.day_of_the_week(year, month, day)
-  end
-
-  @doc """
-  Converts the given time into a string.
-  """
-  def time_to_string(hour, minute, second, microsecond, format \\ :extended)
-
-  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.
-  """
-  def date_to_string(year, month, day) do
-    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
-  end
-
-  defp date_to_string(year, month, day, :extended), do: date_to_string(year, month, day)
-  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.
-  """
-  def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do
-    date_to_string(year, month, day) <> " " <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Convers the datetime (with time zone) into a string.
-  """
-  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) <> " " <>
-      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
-
-  def valid_date?(year, month, day) do
-    year <= 9999 and :calendar.valid_date(year, month, day)
-  end
-
-  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
-  end
-
-  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
-    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
-    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) do
-    num = Integer.to_string(val)
-    :binary.copy("0", count - byte_size(num)) <> num
-  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} = :calendar.gregorian_seconds_to_datetime(seconds)
-      {:ok, date, time, {microseconds, precision}}
-    else
-      {:error, :invalid_unix_time}
-    end
-  end
-
-  defp precision_for_unit(unit) do
-    subsecond = div System.convert_time_unit(1, :second, unit), 10
-    precision_for_unit(subsecond, 0)
-  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
-  def date_to_iso8601(year, month, day, format \\ :extended) do
-    date_to_string(year, month, day, format)
-  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)
-  end
-
-  @doc false
-  def parse_microsecond("." <> rest) 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}
-
-  @doc false
-  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
-
-  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}
-    else
-      _ -> :error
-    end
-  end
-
-  @doc false
-  def iso_days_to_unit({days, {parts, ppd}}, unit) do
-    day_microseconds = days * @seconds_per_day * @microseconds_per_second
-    microseconds = div(parts * @seconds_per_day * @microseconds_per_second, ppd)
-    System.convert_time_unit(day_microseconds + microseconds, :microsecond, unit)
-  end
-
-  @doc false
-  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
-end

lib/elixir/lib/calendar/naive_datetime.ex

@@ -1,695 +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/7` functions or using the `~N` 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 on 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 `==`, `>`, `<` 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 amount of seconds betweens instants.
-  For example, if there is an interest in computing the amount 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], 1271512800)
-      ~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
-
-  """
-  @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}
-
-  """
-  @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) do
-    with {:ok, date} <- Date.new(year, month, day, calendar),
-         {:ok, time} <- Time.new(hour, minute, second, microsecond, calendar),
-         do: new(date, time)
-  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, year: year, month: month, day: day},
-          %Time{calendar: calendar, hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    {:ok, %NaiveDateTime{calendar: calendar, year: year, month: month, day: day,
-                         hour: hour, minute: minute, second: second, microsecond: microsecond}}
-  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 be 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], 63579428950)
-      ~N[2014-10-02 00:29:10]
-
-  """
-  @spec add(t, integer, System.time_unit) :: t
-  def add(%NaiveDateTime{microsecond: {_, precision}, calendar: calendar} = naive_datetime,
-          integer, unit \\ :second) when is_integer(integer) do
-    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
-
-      # to Gregorian seconds
-      iex> NaiveDateTime.diff(~N[2014-10-02 00:29:10], ~N[0000-01-01 00:00:00])
-      63579428950
-
-  """
-  @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 """
-  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{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: calendar}) do
-    %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"
-
-  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(naive_datetime)
-
-  def to_string(%{calendar: calendar, year: year, month: month, day: day,
-                  hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    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).
-
-  Timezone 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 ISO8601 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(<<year::4-bytes, ?-, month::2-bytes, ?-, day::2-bytes, sep,
-                     hour::2-bytes, ?:, min::2-bytes, ?:, sec::2-bytes, rest::binary>>, calendar) when sep in [?\s, ?T] do
-    with {year, ""} <- Integer.parse(year),
-         {month, ""} <- Integer.parse(month),
-         {day, ""} <- Integer.parse(day),
-         {hour, ""} <- Integer.parse(hour),
-         {min, ""} <- Integer.parse(min),
-         {sec, ""} <- Integer.parse(sec),
-         {microsec, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {_offset, ""} <- Calendar.ISO.parse_offset(rest) do
-      with {:ok, utc_date} <- new(year, month, day, hour, min, sec, microsec, Calendar.ISO),
-           do: convert(utc_date, calendar)
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  def from_iso8601(<<_::binary>>, _calendar) do
-    {:error, :invalid_format}
-  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 ISO8601 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(%{year: year, month: month, day: day,
-                   hour: hour, minute: minute, second: second, microsecond: microsecond, calendar:
-    Calendar.ISO}, format) when format in [:basic, :extended] do
-    Calendar.ISO.naive_datetime_to_iso8601(year, month, day, hour, minute, second, microsecond, format)
-  end
-
-  def to_iso8601(%{year: _, month: _, day: _,
-                   hour: _, minute: _, second: _, microsecond: _, calendar: _} = naive_datetime, format) when format in [:basic, :extended] do
-    naive_datetime
-    |> convert!(Calendar.ISO)
-    |> to_iso8601(format)
-  end
-
-  def to_iso8601(_date, format) do
-    raise ArgumentError, "NaiveDateTime.to_iso8601/2 expects format to be :extended or :basic, got: #{inspect 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(t) :: :calendar.datetime
-  def to_erl(naive_datetime)
-
-  @spec to_erl(Calendar.time) :: :calendar.time
-  def to_erl(%{calendar: _, year: _, month: _, day: _,
-               hour: _, minute: _, second: _} = 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) :: {: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) :: t | no_return
-  def from_erl!(tuple, microsecond \\ {0, 0}) do
-    case from_erl(tuple, microsecond) 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
-
-  """
-  @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}}}
-
-  """
-  @spec convert(Calendar.naive_datetime, Calendar.calendar) :: {:ok, t} | {:error, :incompatible_calendars}
-  def convert(%{calendar: calendar, year: year, month: month, day: day,
-                hour: hour, minute: minute, second: second, microsecond: microsecond}, calendar) do
-    {:ok, %NaiveDateTime{calendar: calendar, year: year, month: month, day: day,
-                         hour: hour, minute: minute, second: second, microsecond: microsecond}}
-  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}}
-
-  """
-  @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
-
-  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(%{calendar: calendar, year: year, month: month, day: day,
-                    hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-      calendar.naive_datetime_to_string(year, month, day, hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{calendar: Calendar.ISO, year: year, month: month, day: day,
-                  hour: hour, minute: minute, second: second, microsecond: microsecond}, _) do
-      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,491 +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`
-  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 `==`, `>`, `<` 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
-
-  """
-  @spec utc_now(Calendar.calendar) :: t
-  def utc_now(calendar \\ Calendar.ISO) do
-    {:ok, _, {hour, minute, second}, microsecond} = Calendar.ISO.from_unix(:os.system_time, :native)
-    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, 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 ->
-        {:ok, %Time{hour: hour, minute: minute, second: second, microsecond: {microsecond, precision}, calendar: calendar}}
-      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).
-
-  Timezone 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 ISO8601 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) :: {:ok, t} | {:error, atom}
-  def from_iso8601(string, calendar \\ Calendar.ISO)
-
-  def from_iso8601(<<?T, h, rest::binary>>, calendar) when h in ?0..?9 do
-    from_iso8601(<<h, rest::binary>>, calendar)
-  end
-
-  def from_iso8601(<<hour::2-bytes, ?:, min::2-bytes, ?:, sec::2-bytes, rest::binary>>, calendar) do
-    with {hour, ""} <- Integer.parse(hour),
-         {min, ""} <- Integer.parse(min),
-         {sec, ""} <- Integer.parse(sec),
-         {microsec, rest} <- Calendar.ISO.parse_microsecond(rest),
-         {_offset, ""} <- Calendar.ISO.parse_offset(rest) do
-      with {:ok, utc_time} <- new(hour, min, sec, microsec, Calendar.ISO),
-           do: convert(utc_time, calendar)
-    else
-      _ -> {:error, :invalid_format}
-    end
-  end
-
-  def from_iso8601(<<_::binary>>, _calendar) do
-    {:error, :invalid_format}
-  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) :: t
-  def from_iso8601!(string) do
-    case from_iso8601(string) 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) when format in [:extended, :basic] do
-    %{hour: hour, minute: minute, second: second, microsecond: microsecond} = convert!(time, Calendar.ISO)
-    Calendar.ISO.time_to_iso8601(hour, minute, second, microsecond, 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 """
-  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
-
-  """
-  @spec compare(Calendar.time, Calendar.time) :: :lt | :eq | :gt
-  def compare(%{calendar: calendar, hour: hour1, minute: minute1, second: second1, microsecond: {microsecond1, _}},
-              %{calendar: calendar, hour: hour2, minute: minute2, second: second2, microsecond: {microsecond2, _}}) do
-    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}}}
-
-  """
-  @spec convert(Calendar.time, Calendar.calendar) :: {:ok, t} | {:error, atom}
-  def convert(%{calendar: calendar, hour: hour, minute: minute, second: second, microsecond: microsecond}, calendar) do
-    {:ok, %Time{calendar: calendar, hour: hour, minute: minute, second: second, microsecond: microsecond}}
-  end
-
-  def convert(%{microsecond: {_, precision}} = time, calendar) do
-    {hour, minute, second, {microsecond, _}} =
-      time
-      |> to_day_fraction()
-      |> calendar.time_from_day_fraction
-    {:ok, %Time{calendar: calendar, hour: hour, minute: minute, second: second,
-                microsecond: {microsecond, precision}}}
-  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}}
-
-  """
-  @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
-
-  """
-  @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
-
-  ## 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(%{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: calendar}) do
-      calendar.time_to_string(hour, minute, second, microsecond)
-    end
-  end
-
-  defimpl Inspect do
-    def inspect(%{hour: hour, minute: minute, second: second, microsecond: microsecond, calendar: Calendar.ISO}, _) do
-      "~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.ex

@@ -56,11 +56,11 @@ defmodule Code do
 
   """
   def append_path(path) do
-    :code.add_pathz(to_charlist(Path.expand path))
+    :code.add_pathz(to_char_list(Path.expand path))
   end
 
   @doc """
-  Prepends a path to the beginning of the Erlang VM code path list.
+  Prepends a path to the begining of the Erlang VM code path list.
 
   This is the list of directories the Erlang VM uses for finding
   module code.
@@ -76,7 +76,7 @@ defmodule Code do
 
   """
   def prepend_path(path) do
-    :code.add_patha(to_charlist(Path.expand path))
+    :code.add_patha(to_char_list(Path.expand path))
   end
 
   @doc """
@@ -95,7 +95,7 @@ defmodule Code do
 
   """
   def delete_path(path) do
-    :code.del_path(to_charlist(Path.expand path))
+    :code.del_path(to_char_list(Path.expand path))
   end
 
   @doc """
@@ -104,15 +104,7 @@ defmodule Code do
   The `binding` argument is a keyword list of variable bindings.
   The `opts` argument is a keyword list of environment options.
 
-  **Warning**: `string` can be any Elixir code and will be executed with
-  the same privileges as the Erlang VM: this means that such code could
-  compromise the machine (for example by executing system commands).
-  Don't use `eval_string/3` with untrusted input (such as strings coming
-  from the network).
-
-  ## Options
-
-  Options can be:
+  Those options can be:
 
     * `:file` - the file to be considered in the evaluation
     * `:line` - the line on which the script starts
@@ -134,7 +126,7 @@ defmodule Code do
   Notice that setting any of the values above overrides Elixir's default
   values. For example, setting `:requires` to `[]`, will no longer
   automatically require the `Kernel` module; in the same way setting
-  `:macros` will no longer auto-import `Kernel` macros like `if/2`, `case/2`,
+  `:macros` will no longer auto-import `Kernel` macros like `if`, `case`,
   etc.
 
   Returns a tuple of the form `{value, binding}`,
@@ -156,7 +148,7 @@ defmodule Code do
       iex> Code.eval_string("a = a + b", [a: 1, b: 2])
       {3, [a: 3, b: 2]}
 
-  For convenience, you can pass `__ENV__/0` as the `opts` argument and
+  For convenience, you can pass `__ENV__` as the `opts` argument and
   all imports, requires and aliases defined in the current environment
   will be automatically carried over:
 
@@ -167,25 +159,20 @@ defmodule Code do
   def eval_string(string, binding \\ [], opts \\ [])
 
   def eval_string(string, binding, %Macro.Env{} = env) do
-    {value, binding, _env, _scope} = :elixir.eval to_charlist(string), binding, Map.to_list(env)
+    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, Map.to_list(env)
     {value, binding}
   end
 
   def eval_string(string, binding, opts) when is_list(opts) do
     validate_eval_opts(opts)
-    {value, binding, _env, _scope} = :elixir.eval to_charlist(string), binding, opts
+    {value, binding, _env, _scope} = :elixir.eval to_char_list(string), binding, opts
     {value, binding}
   end
 
   @doc """
   Evaluates the quoted contents.
 
-  **Warning**: Calling this function inside a macro is considered bad
-  practice as it will attempt to evaluate runtime values at compile time.
-  Macro arguments are typically transformed by unquoting them into the
-  returned quoted expressions (instead of evaluated).
-
-  See `eval_string/3` for a description of bindings and options.
+  See `eval_string/3` for a description of arguments and return values.
 
   ## Examples
 
@@ -193,7 +180,7 @@ defmodule Code do
       iex> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
       {3, [a: 1, b: 2]}
 
-  For convenience, you can pass `__ENV__/0` as the `opts` argument and
+  For convenience, you can pass `__ENV__` as the `opts` argument and
   all options will be automatically extracted from the current environment:
 
       iex> contents = quote(do: var!(a) + var!(b))
@@ -260,9 +247,9 @@ defmodule Code do
   ## Options
 
     * `:file` - the filename to be used in stacktraces
-      and the file reported in the `__ENV__/0` macro
+      and the file reported in the `__ENV__` variable
 
-    * `:line` - the line reported in the `__ENV__/0` macro
+    * `:line` - the line reported in the `__ENV__` variable
 
     * `:existing_atoms_only` - when `true`, raises an error
       when non-existing atoms are found by the tokenizer
@@ -276,7 +263,7 @@ defmodule Code do
   def string_to_quoted(string, opts \\ []) when is_list(opts) do
     file = Keyword.get opts, :file, "nofile"
     line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted(to_charlist(string), line, file, opts)
+    :elixir.string_to_quoted(to_char_list(string), line, file, opts)
   end
 
   @doc """
@@ -292,7 +279,7 @@ defmodule Code do
   def string_to_quoted!(string, opts \\ []) when is_list(opts) do
     file = Keyword.get opts, :file, "nofile"
     line = Keyword.get opts, :line, 1
-    :elixir.string_to_quoted!(to_charlist(string), line, file, opts)
+    :elixir.string_to_quoted!(to_char_list(string), line, file, opts)
   end
 
   @doc """
@@ -324,7 +311,7 @@ defmodule Code do
 
   ## Examples
 
-      Code.load_file("eex_test.exs", "../eex/test") |> List.first
+      Code.load_file("eex_test.exs","../eex/test") |> List.first
       #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
 
   """
@@ -341,11 +328,11 @@ defmodule Code do
 
   Accepts `relative_to` as an argument to tell where the file is located.
   The return value is the same as that of `load_file/2`. If the file was already
-  required/loaded, `require_file` doesn't do anything and returns `nil`.
+  required/loaded, doesn't do anything and returns `nil`.
 
   Notice that if `require_file` is invoked by different processes concurrently,
   the first process to invoke `require_file` acquires a lock and the remaining
-  ones will block until the file is available. I.e., if `require_file` is called
+  ones will block until the file is available. I.e. if `require_file` is called
   N times with a given file, it will be loaded only once. The first process to
   call `require_file` will get the list of loaded modules, others will get `nil`.
 
@@ -356,11 +343,11 @@ defmodule Code do
 
   If the code is already loaded, it returns `nil`:
 
-      Code.require_file("eex_test.exs", "../eex/test") #=> nil
+      Code.require_file("eex_test.exs","../eex/test") #=> nil
 
   If the code is not loaded yet, it returns the same as `load_file/2`:
 
-      Code.require_file("eex_test.exs", "../eex/test") |> List.first
+      Code.require_file("eex_test.exs","../eex/test") |> List.first
       #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
 
   """
@@ -402,12 +389,12 @@ defmodule Code do
 
   ## Examples
 
-      iex> Code.available_compiler_options
-      [:docs, :debug_info, :ignore_module_conflict, :relative_paths, :warnings_as_errors]
+      Code.available_compiler_options
+      #=> [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
 
   """
   def available_compiler_options do
-    [:docs, :debug_info, :ignore_module_conflict, :relative_paths, :warnings_as_errors]
+    [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
   end
 
   @doc """
@@ -427,11 +414,7 @@ defmodule Code do
     * `:ignore_module_conflict` - when `true`, override modules that were
       already defined without raising errors, `false` by default
 
-    * `:relative_paths` - when `true`, use relative paths in quoted nodes,
-      warnings and errors generated by the compiler, `true` by default.
-      Note disabling this option won't affect runtime warnings and errors.
-
-    * `:warnings_as_errors` - causes compilation to fail when warnings are
+    * `:warnings_as_errors` - cause compilation to fail when warnings are
       generated
 
   It returns the new list of compiler options.
@@ -446,16 +429,9 @@ defmodule Code do
   def compiler_options(opts) do
     available = available_compiler_options()
 
-    Enum.each(opts, fn({key, value}) ->
-      cond do
-        key not in available ->
-          raise "unknown compiler option: #{inspect(key)}"
-        not is_boolean(value) ->
-          raise "compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}"
-        true ->
-          :ok
-      end
-    end)
+    for {k, _} <- opts,
+        not k in available,
+        do: raise "unknown compiler options: #{k}"
 
     :elixir_config.update :compiler_options, &Enum.into(opts, &1)
   end
@@ -469,7 +445,7 @@ defmodule Code do
   For compiling many files at once, check `Kernel.ParallelCompiler.files/2`.
   """
   def compile_string(string, file \\ "nofile") when is_binary(file) do
-    :elixir_compiler.string to_charlist(string), file
+    :elixir_compiler.string to_char_list(string), file
   end
 
   @doc """
@@ -504,7 +480,7 @@ defmodule Code do
   module uses this function to check if a specific parser exists for a given
   URI scheme.
 
-  ## `ensure_compiled/1`
+  ## Code.ensure_compiled/1
 
   Elixir also contains an `ensure_compiled/1` function that is a
   superset of `ensure_loaded/1`.
@@ -513,13 +489,8 @@ defmodule Code do
   you may need to use a module that was not yet compiled, therefore
   it can't even be loaded.
 
-  When invoked, `ensure_compiled/1` halts the compilation of the caller
-  until the module given to `ensure_compiled/1` becomes available or
-  all files for the current project have been compiled. If compilation
-  finishes and the module is not available, an error tuple is returned.
-
-  `ensure_compiled/1` does not apply to dependencies, as dependencies
-  must be compiled upfront.
+  `ensure_compiled/1` halts the current process until the
+  module we are depending on is available.
 
   In most cases, `ensure_loaded/1` is enough. `ensure_compiled/1`
   must be used in rare cases, usually involving macros that need to
@@ -534,8 +505,6 @@ defmodule Code do
       {:error, :nofile}
 
   """
-  @spec ensure_loaded(module) ::
-        {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}
   def ensure_loaded(module) when is_atom(module) do
     :code.ensure_loaded(module)
   end
@@ -553,7 +522,7 @@ defmodule Code do
       true
 
   """
-  def ensure_loaded?(module) when is_atom(module) do
+  def ensure_loaded?(module) do
     match?({:module, ^module}, ensure_loaded(module))
   end
 
@@ -570,16 +539,18 @@ defmodule Code do
   Check `ensure_loaded/1` for more information on module loading
   and when to use `ensure_loaded/1` or `ensure_compiled/1`.
   """
-  @spec ensure_compiled(module) ::
-        {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}
   def ensure_compiled(module) when is_atom(module) do
     case :code.ensure_loaded(module) do
       {:error, :nofile} = error ->
-        if is_pid(:erlang.get(:elixir_compiler_pid)) and
-           Kernel.ErrorHandler.ensure_compiled(module, :module) do
-          {:module, module}
-        else
-          error
+        case :erlang.get(:elixir_ensure_compiled) do
+          :undefined -> error
+          _ ->
+            try do
+              module.__info__(:module)
+              {:module, module}
+            rescue
+              UndefinedFunctionError -> error
+            end
         end
       other -> other
     end
@@ -592,8 +563,7 @@ defmodule Code do
   is already loaded or was successfully loaded and compiled.
   Returns `false` otherwise.
   """
-  @spec ensure_compiled?(module) :: boolean
-  def ensure_compiled?(module) when is_atom(module) do
+  def ensure_compiled?(module) do
     match?({:module, ^module}, ensure_compiled(module))
   end
 
@@ -627,10 +597,11 @@ defmodule Code do
 
   ## Examples
 
-      # Get the module documentation
-      iex> {_line, text} = Code.get_docs(Atom, :moduledoc)
+      # Get the documentation for the first function listed
+      iex> [fun|_] = Code.get_docs(Atom, :docs) |> Enum.sort()
+      iex> {{_function, _arity}, _line, _kind, _signature, text} = fun
       iex> String.split(text, "\n") |> Enum.at(0)
-      "Convenience functions for working with atoms."
+      "Converts an atom to a char list."
 
       # Module doesn't exist
       iex> Code.get_docs(ModuleNotGood, :all)
@@ -649,7 +620,7 @@ defmodule Code do
   end
 
   def get_docs(binpath, kind) when is_binary(binpath) and kind in @doc_kinds do
-    do_get_docs(String.to_charlist(binpath), kind)
+    do_get_docs(String.to_char_list(binpath), kind)
   end
 
   @docs_chunk 'ExDc'

lib/elixir/lib/collectable.ex

@@ -13,7 +13,7 @@ defprotocol Collectable do
   The `Enumerable` protocol is useful to take values out of a collection.
   In order to support a wide range of values, the functions provided by
   the `Enumerable` protocol do not keep shape. For example, passing a
-  map to `Enum.map/2` always returns a list.
+  dictionary to `Enum.map/2` always returns a list.
 
   This design is intentional. `Enumerable` was designed to support infinite
   collections, resources and other structures with fixed shape. For example,
@@ -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)
@@ -80,7 +49,7 @@ end
 defimpl Collectable, for: List do
   def into(original) do
     {[], fn
-      list, {:cont, x} -> [x | list]
+      list, {:cont, x} -> [x|list]
       list, :done -> original ++ :lists.reverse(list)
       _, :halt -> :ok
     end}
@@ -90,7 +59,7 @@ end
 defimpl Collectable, for: BitString do
   def into(original) do
     {original, fn
-      acc, {:cont, x} when is_bitstring(x) -> [acc | x]
+      acc, {:cont, x} when is_bitstring(x) -> [acc|x]
       acc, :done -> IO.iodata_to_binary(acc)
       _, :halt -> :ok
     end}

lib/elixir/lib/dict.ex

@@ -13,14 +13,46 @@ defmodule Dict do
   @type value :: any
   @type t :: list | map
 
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
+  # TODO: Remove callbacks on 1.3
+  # TODO: Deprecate every function on 1.3
+  @callback new :: t
+  @callback delete(t, key) :: t
+  @callback drop(t, Enum.t) :: t
+  @callback equal?(t, t) :: boolean
+  @callback get(t, key) :: value
+  @callback get(t, key, value) :: value
+  @callback get_lazy(t, key, (() -> value)) :: value
+  @callback get_and_update(t, key, (value -> {value, value})) :: {value, t}
+  @callback fetch(t, key) :: {:ok, value} | :error
+  @callback fetch!(t, key) :: value | no_return
+  @callback has_key?(t, key) :: boolean
+  @callback keys(t) :: [key]
+  @callback merge(t, t) :: t
+  @callback merge(t, t, (key, value, value -> value)) :: t
+  @callback pop(t, key) :: {value, t}
+  @callback pop(t, key, value) :: {value, t}
+  @callback pop_lazy(t, key, (() -> value)) :: {value, t}
+  @callback put(t, key, value) :: t
+  @callback put_new(t, key, value) :: t
+  @callback put_new_lazy(t, key, (() -> value)) :: t
+  @callback size(t) :: non_neg_integer()
+  @callback split(t, Enum.t) :: {t, t}
+  @callback take(t, Enum.t) :: t
+  @callback to_list(t) :: list()
+  @callback update(t, key, value, (value -> value)) :: t
+  @callback update!(t, key, (value -> value)) :: t | no_return
+  @callback values(t) :: list(value)
 
   defmacro __using__(_) do
     # Use this import to guarantee proper code expansion
     import Kernel, except: [size: 1]
 
+    %{file: file, line: line} = __CALLER__
+    :elixir_errors.warn(line, file, "the Dict module is deprecated")
+
     quote do
+      @behaviour Dict
+
       def get(dict, key, default \\ nil) do
         case fetch(dict, key) do
           {:ok, value} -> value
@@ -71,7 +103,7 @@ defmodule Dict do
       end
 
       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
@@ -81,19 +113,19 @@ defmodule Dict do
 
       def to_list(dict) do
         reduce(dict, {:cont, []}, fn
-          kv, acc -> {:cont, [kv | acc]}
+          kv, acc -> {:cont, [kv|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
       def keys(dict) do
         reduce(dict, {:cont, []}, fn
-          {k, _}, acc -> {:cont, [k | acc]}
+          {k, _}, acc -> {:cont, [k|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
       def values(dict) do
         reduce(dict, {:cont, []}, fn
-          {_, v}, acc -> {:cont, [v | acc]}
+          {_, v}, acc -> {:cont, [v|acc]}
         end) |> elem(1) |> :lists.reverse
       end
 
@@ -165,7 +197,7 @@ defmodule Dict do
       end
 
       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)}
@@ -360,7 +392,6 @@ defmodule Dict do
     target(dict).to_list(dict)
   end
 
-  @spec unsupported_dict(t) :: no_return
   defp unsupported_dict(dict) do
     raise ArgumentError, "unsupported dict: #{inspect dict}"
   end

lib/elixir/lib/exception.ex

@@ -7,7 +7,7 @@ defmodule Exception do
   `System.stacktrace/0` will return the stacktrace for the
   last throw/error/exit that occurred in the current process.
 
-  Do not rely on the particular format returned by the `format*`
+  Do not rely on the particular format returned by the `format`
   functions in this module. They may be changed in future releases
   in order to better suit Elixir's tool chain. In other words,
   by using the functions in this module it is guaranteed you will
@@ -15,15 +15,10 @@ defmodule Exception do
   """
 
   @typedoc "The exception type"
-  @type t :: %{
-    required(:__struct__) => module,
-    required(:__exception__) => true,
-    atom => any
-  }
+  @type t :: %{__struct__: module, __exception__: true}
 
   @typedoc "The kind handled by formatting functions"
-  @type kind :: :error | non_error_kind
-  @typep non_error_kind :: :exit | :throw | {:EXIT, pid}
+  @type kind :: :error | :exit | :throw | {:EXIT, pid}
 
   @type stacktrace :: [stacktrace_entry]
   @type stacktrace_entry ::
@@ -31,7 +26,7 @@ defmodule Exception do
         {(... -> any), arity_or_args, location}
 
   @typep arity_or_args :: non_neg_integer | list
-  @typep location :: keyword
+  @typep location :: Keyword.t
 
   @callback exception(term) :: t
   @callback message(t) :: String.t
@@ -81,7 +76,7 @@ defmodule Exception do
   an empty stacktrace, `[]`, must be used.
   """
   @spec normalize(:error, any, stacktrace) :: t
-  @spec normalize(non_error_kind, payload, stacktrace) :: payload when payload: var
+  @spec normalize(kind, payload, stacktrace) :: payload when payload: var
 
   # Generating a stacktrace is expensive, default to nil
   # to only fetch it when needed.
@@ -141,7 +136,9 @@ defmodule Exception do
   Note that `{:EXIT, pid}` do not generate a stacktrace though
   (as they are retrieved as messages without stacktraces).
   """
+
   @spec format(kind, any, stacktrace | nil) :: String.t
+
   def format(kind, payload, stacktrace \\ nil)
 
   def format({:EXIT, _} = kind, any, _) do
@@ -157,162 +154,6 @@ defmodule Exception do
     end
   end
 
-  @doc """
-  Attaches information to exceptions for extra debugging.
-
-  This operation is potentially expensive, as it reads data
-  from the filesystem, parse beam files, evaluates code and
-  so on. Currently the following exceptions may be annotated:
-
-    * `FunctionClauseError` - annotated with the arguments
-      used on the call and available clauses
-
-  """
-  @spec blame(:error, any, stacktrace) :: {t, stacktrace}
-  @spec blame(non_error_kind, payload, stacktrace) :: {payload, stacktrace} when payload: var
-  def blame(kind, error, stacktrace)
-
-  def blame(:error, error, stacktrace) do
-    case normalize(:error, error, stacktrace) do
-      %{__struct__: FunctionClauseError} = struct ->
-        blame_function_clause_error(struct, stacktrace)
-      _ ->
-        {error, stacktrace}
-    end
-  end
-
-  def blame(_kind, reason, stacktrace) do
-    {reason, stacktrace}
-  end
-
-  defp blame_function_clause_error(%{module: module, function: function, arity: arity} = exception,
-                                   [{module, function, args, meta} | rest])
-       when length(args) == arity do
-    exception =
-      case blame_mfa(module, function, args) do
-        {:ok, kind, clauses} -> %{exception | args: args, kind: kind, clauses: clauses}
-        :error -> %{exception | args: args}
-      end
-    {exception, [{module, function, arity, meta} | rest]}
-  end
-  defp blame_function_clause_error(exception, stacktrace) do
-    {exception, stacktrace}
-  end
-
-  @doc """
-  Blames the invocation of the given module, function and arguments.
-
-  This function will retrieve the available clauses from bytecode
-  and evaluate them against the given arguments. The clauses are
-  returned as a list of `{args, guards}` pairs where each argument
-  and each top-level condition in a guard separated by `and`/`or`
-  is wrapped in a tuple with blame metadata.
-
-  This function returns either `{:ok, definition, clauses}` or `:error`.
-  Where `definition` is `:def`, `:defp`, `:defmacro` or `:defmacrop`.
-  Note this functionality requires Erlang/OTP 20, otherwise `:error`
-  is always returned.
-  """
-  @spec blame_mfa(module, function, args :: [term]) ::
-        {:ok, :def | :defp | :defmacro | :defmacrop, [{args :: [term], guards :: [term]}]} | :error
-  def blame_mfa(module, function, args) when is_atom(module) and is_atom(function) and is_list(args) do
-    try do
-      blame_mfa(module, function, length(args), args)
-    rescue
-      _ -> :error
-    end
-  end
-
-  defp blame_mfa(module, function, arity, call_args) do
-    with path when is_list(path) <- :code.which(module),
-         {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <- :beam_lib.chunks(path, [:debug_info]),
-         {:ok, %{definitions: defs}} <- backend.debug_info(:elixir_v1, module, data, []),
-         {_, kind, _, clauses} <- List.keyfind(defs, {function, arity}, 0) do
-      clauses =
-        for {meta, ex_args, guards, _block} <- clauses do
-          scope = :elixir_erl.definition_scope(meta, "nofile")
-          {erl_args, scope} =
-            :elixir_erl_clauses.match(&:elixir_erl_pass.translate_args/2, ex_args, scope)
-          {args, binding} =
-            [call_args, ex_args, erl_args]
-            |> Enum.zip()
-            |> Enum.map_reduce([], &blame_arg/2)
-          guards = Enum.map(guards, &blame_guard(&1, scope, binding))
-          {args, guards}
-        end
-      {:ok, kind, clauses}
-    else
-      _ -> :error
-    end
-  end
-
-  defp blame_arg({call_arg, ex_arg, erl_arg}, binding) do
-    {match?, binding} = blame_arg(erl_arg, call_arg, binding)
-    {blame_wrap(match?, rewrite_arg(ex_arg)), binding}
-  end
-
-  defp blame_arg(erl_arg, call_arg, binding) do
-    binding = :orddict.store(:VAR, call_arg, binding)
-    try do
-      {:value, _, binding} = :erl_eval.expr({:match, 0, erl_arg, {:var, 0, :VAR}}, binding, :none)
-      {true, binding}
-    rescue
-      _ -> {false, binding}
-    end
-  end
-
-  defp rewrite_arg(arg) do
-    Macro.prewalk(arg, fn
-      {:%{}, meta, [__struct__: Range, first: first, last: last]} ->
-        {:.., meta, [first, last]}
-      other ->
-        other
-    end)
-  end
-
-  defp blame_guard({{:., _, [:erlang, op]}, meta, [left, right]}, scope, binding)
-       when op == :andalso or op == :orelse do
-    {rewrite_guard_call(op), meta, [
-      blame_guard(left, scope, binding),
-      blame_guard(right, scope, binding)
-    ]}
-  end
-
-  defp blame_guard(ex_guard, scope, binding) do
-    {erl_guard, _} = :elixir_erl_pass.translate(ex_guard, scope)
-    match? =
-      try do
-        {:value, true, _} = :erl_eval.expr(erl_guard, binding, :none)
-        true
-      rescue
-        _ -> false
-      end
-    blame_wrap(match?, rewrite_guard(ex_guard))
-  end
-
-  defp rewrite_guard(guard) do
-    Macro.prewalk(guard, fn
-      {:., _, [:erlang, call]} -> rewrite_guard_call(call)
-      other -> other
-    end)
-  end
-
-  defp rewrite_guard_call(:"orelse"), do: :or
-  defp rewrite_guard_call(:"andalso"), do: :and
-  defp rewrite_guard_call(:"=<"), do: :<=
-  defp rewrite_guard_call(:"/="), do: :!=
-  defp rewrite_guard_call(:"=:="), do: :===
-  defp rewrite_guard_call(:"=/="), do: :!==
-
-  defp rewrite_guard_call(op) when op in [:band, :bor, :bnot, :bsl, :bsr, :bxor],
-    do: {:., [], [Bitwise, op]}
-  defp rewrite_guard_call(op) when op in [:xor, :element, :size],
-    do: {:., [], [:erlang, op]}
-  defp rewrite_guard_call(op),
-    do: op
-
-  defp blame_wrap(match?, ast), do: %{match?: match?, node: ast}
-
   @doc """
   Formats an exit. It returns a string.
 
@@ -389,13 +230,12 @@ defmodule Exception do
     "shutdown: #{inspect(reason)}"
   end
 
-  defp format_exit_reason(:calling_self), do: "process attempted to call itself"
   defp format_exit_reason(:timeout), do: "time out"
   defp format_exit_reason(:killed), do: "killed"
   defp format_exit_reason(:noconnection), do: "no connection"
 
   defp format_exit_reason(:noproc) do
-    "no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started"
+    "no process"
   end
 
   defp format_exit_reason({:nodedown, node_name}) when is_atom(node_name) do
@@ -429,15 +269,15 @@ defmodule Exception do
   end
 
   defp format_exit_reason({:bad_start_spec, start_spec}) do
-    "bad child specification, invalid children: " <> inspect(start_spec)
+    "bad start spec: invalid children: " <> inspect(start_spec)
   end
 
   defp format_exit_reason({:start_spec, start_spec}) do
-    "bad child specification, " <> format_sup_spec(start_spec)
+    "bad start spec: " <> format_sup_spec(start_spec)
   end
 
   defp format_exit_reason({:supervisor_data, data}) do
-    "bad supervisor configuration, " <> format_sup_data(data)
+    "bad supervisor data: " <> format_sup_data(data)
   end
 
   defp format_exit_reason(reason), do: inspect(reason)
@@ -456,57 +296,44 @@ defmodule Exception do
   end
 
   defp format_sup_data({:invalid_intensity, intensity}) do
-    "invalid max_restarts (intensity): " <> inspect(intensity)
+    "invalid intensity: " <> inspect(intensity)
   end
 
   defp format_sup_data({:invalid_period, period}) do
-    "invalid max_seconds (period): " <> inspect(period)
+    "invalid period: " <> inspect(period)
   end
 
-  defp format_sup_data(other), do: "got: #{inspect other}"
-
-  defp format_sup_spec({:duplicate_child_name, id}) do
-    """
-    more than one child specification has the id: #{inspect id}.
-    If using maps as child specifications, make sure the :id keys are unique.
-    If using a module or {module, arg} as child, use Supervisor.child_spec/2 to change the :id, for example:
-
-        children = [
-          Supervisor.child_spec({MyWorker, arg}, id: :my_worker_1),
-          Supervisor.child_spec({MyWorker, arg}, id: :my_worker_2)
-        ]
-    """
-  end
+  defp format_sup_data(other), do: inspect(other)
 
   defp format_sup_spec({:invalid_child_spec, child_spec}) do
-   "invalid child specification: #{inspect child_spec}"
+   "invalid child spec: " <> inspect(child_spec)
   end
 
   defp format_sup_spec({:invalid_child_type, type}) do
-    "invalid child type: #{inspect type}. Must be :worker or :supervisor."
+    "invalid child type: " <> inspect(type)
   end
 
   defp format_sup_spec({:invalid_mfa, mfa}) do
-    "invalid mfa: #{inspect mfa}"
+    "invalid mfa: " <> inspect(mfa)
   end
 
   defp format_sup_spec({:invalid_restart_type, restart}) do
-    "invalid restart type: #{inspect restart}. Must be :permanent, :transient or :temporary."
+    "invalid restart type: " <> inspect(restart)
   end
 
   defp format_sup_spec({:invalid_shutdown, shutdown}) do
-    "invalid shutdown: #{inspect shutdown}. Must be an integer >= 0, :infinity or :brutal_kill."
+    "invalid shutdown: " <> inspect(shutdown)
   end
 
   defp format_sup_spec({:invalid_module, mod}) do
-    "invalid module: #{inspect mod}. Must be an atom."
+    "invalid module: " <> inspect(mod)
   end
 
   defp format_sup_spec({:invalid_modules, modules}) do
-    "invalid modules: #{inspect modules}. Must be a list of atoms or :dynamic."
+    "invalid modules: " <> inspect(modules)
   end
 
-  defp format_sup_spec(other), do: "got: #{inspect other}"
+  defp format_sup_spec(other), do: inspect(other)
 
   @doc """
   Receives a stacktrace entry and formats it into a string.
@@ -538,10 +365,10 @@ defmodule Exception do
   end
 
   defp format_application(module) do
-    # We cannot use Application due to bootstrap issues
-    case :application.get_application(module) do
-      {:ok, app} -> "(" <> Atom.to_string(app) <> ") "
-      :undefined -> ""
+    if app = Application.get_application(module) do
+      "(" <> Atom.to_string(app) <> ") "
+    else
+      ""
     end
   end
 
@@ -552,13 +379,13 @@ defmodule Exception do
   is retrieved from `Process.info/2`.
   """
   def format_stacktrace(trace \\ nil) do
-    trace = trace || case Process.info(self(), :current_stacktrace) do
+    trace = trace || case Process.info(self, :current_stacktrace) do
       {:current_stacktrace, t} -> Enum.drop(t, 3)
     end
 
     case trace do
       [] -> "\n"
-      _ -> "    " <> Enum.map_join(trace, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
+      s  -> "    " <> Enum.map_join(s, "\n    ", &format_stacktrace_entry(&1)) <> "\n"
     end
   end
 
@@ -597,12 +424,17 @@ defmodule Exception do
   "anonymous fn in func/arity"
   """
   def format_mfa(module, fun, arity) when is_atom(module) and is_atom(fun) do
-    case Inspect.Function.extract_anonymous_fun_parent(Atom.to_string(fun)) do
-      {outer_name, outer_arity} ->
-        "anonymous fn#{format_arity(arity)} in " <>
-          "#{inspect(module)}.#{Inspect.Function.escape_name(outer_name)}/#{outer_arity}"
-      :error ->
-        "#{inspect(module)}.#{Inspect.Function.escape_name(fun)}#{format_arity(arity)}"
+    fun =
+      case inspect(fun) do
+        ":" <> fun -> fun
+        fun -> fun
+      end
+
+    case match?("\"-" <> _, fun) and String.split(fun, "-") do
+      [ "\"", outer_fun, "fun", _count, "\"" ] ->
+        "anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}"
+      _ ->
+        "#{inspect module}.#{fun}#{format_arity(arity)}"
     end
   end
 
@@ -631,7 +463,11 @@ defmodule Exception do
       ""
 
   """
-  def format_file_line(file, line, suffix \\ "") do
+  def format_file_line(file, line) do
+    format_file_line(file, line, "")
+  end
+
+  defp format_file_line(file, line, suffix) do
     if file do
       if line && line != 0 do
         "#{file}:#{line}:#{suffix}"
@@ -662,7 +498,11 @@ defmodule ArgumentError do
 end
 
 defmodule ArithmeticError do
-  defexception message: "bad argument in arithmetic expression"
+  defexception []
+
+  def message(_) do
+    "bad argument in arithmetic expression"
+  end
 end
 
 defmodule SystemLimitError do
@@ -674,7 +514,7 @@ defmodule SystemLimitError do
 end
 
 defmodule SyntaxError do
-  defexception [:file, :line, description: "syntax error"]
+  defexception [file: nil, line: nil, description: "syntax error"]
 
   def message(exception) do
     Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
@@ -683,25 +523,25 @@ defmodule SyntaxError do
 end
 
 defmodule TokenMissingError do
-  defexception [:file, :line, description: "expression is incomplete"]
+  defexception [file: nil, line: nil, description: "expression is incomplete"]
 
-  def message(%{file: file, line: line, description: description}) do
-    Exception.format_file_line(file && Path.relative_to_cwd(file), line) <>
-      " " <> description
+  def message(exception) do
+    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
+      " " <> exception.description
   end
 end
 
 defmodule CompileError do
-  defexception [:file, :line, description: "compile error"]
+  defexception [file: nil, line: nil, description: "compile error"]
 
-  def message(%{file: file, line: line, description: description}) do
-    Exception.format_file_line(file && Path.relative_to_cwd(file), line) <>
-      " " <> description
+  def message(exception) do
+    Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <>
+      " " <> exception.description
   end
 end
 
 defmodule BadFunctionError do
-  defexception [:term]
+  defexception [term: nil]
 
   def message(exception) do
     "expected a function, got: #{inspect(exception.term)}"
@@ -709,7 +549,7 @@ defmodule BadFunctionError do
 end
 
 defmodule BadStructError do
-  defexception [:struct, :term]
+  defexception [struct: nil, term: nil]
 
   def message(exception) do
     "expected a struct named #{inspect(exception.struct)}, got: #{inspect(exception.term)}"
@@ -717,23 +557,15 @@ defmodule BadStructError do
 end
 
 defmodule BadMapError do
-  defexception [:term]
+  defexception [term: nil]
 
   def message(exception) do
     "expected a map, got: #{inspect(exception.term)}"
   end
 end
 
-defmodule BadBooleanError do
-  defexception [:term, :operator]
-
-  def message(exception) do
-    "expected a boolean on left-side of \"#{exception.operator}\", got: #{inspect(exception.term)}"
-  end
-end
-
 defmodule MatchError do
-  defexception [:term]
+  defexception [term: nil]
 
   def message(exception) do
     "no match of right hand side value: #{inspect(exception.term)}"
@@ -741,21 +573,13 @@ defmodule MatchError do
 end
 
 defmodule CaseClauseError do
-  defexception [:term]
+  defexception [term: nil]
 
   def message(exception) do
     "no case clause matching: #{inspect(exception.term)}"
   end
 end
 
-defmodule WithClauseError do
-  defexception [:term]
-
-  def message(exception) do
-    "no with clause matching: #{inspect(exception.term)}"
-  end
-end
-
 defmodule CondClauseError do
   defexception []
 
@@ -765,7 +589,7 @@ defmodule CondClauseError do
 end
 
 defmodule TryClauseError do
-  defexception [:term]
+  defexception [term: nil]
 
   def message(exception) do
     "no try clause matching: #{inspect(exception.term)}"
@@ -773,7 +597,7 @@ defmodule TryClauseError do
 end
 
 defmodule BadArityError do
-  defexception [:function, :args]
+  defexception [function: nil, args: nil]
 
   def message(exception) do
     fun  = exception.function
@@ -789,7 +613,7 @@ defmodule BadArityError do
 end
 
 defmodule UndefinedFunctionError do
-  defexception [:module, :function, :arity, :reason, :exports]
+  defexception [module: nil, function: nil, arity: nil, reason: nil]
 
   def message(%{reason: nil, module: module, function: function, arity: arity} = e) do
     cond do
@@ -803,130 +627,36 @@ defmodule UndefinedFunctionError do
   end
 
   def message(%{reason: :"module could not be loaded", module: module, function: function, arity: arity}) do
-    "function " <> Exception.format_mfa(module, function, arity) <>
-      " is undefined (module #{inspect module} is not available)"
+    "undefined function " <> Exception.format_mfa(module, function, arity) <>
+      " (module #{inspect module} is not available)"
   end
 
   def message(%{reason: :"function not exported",  module: module, function: function, arity: arity}) do
-    IO.iodata_to_binary(function_not_exported(module, function, arity, nil))
+    "undefined function " <> Exception.format_mfa(module, function, arity)
   end
 
   def message(%{reason: :"function not available", module: module, function: function, arity: arity}) do
     "nil." <> fa = Exception.format_mfa(nil, function, arity)
-    "function " <> Exception.format_mfa(module, function, arity) <>
-    " is undefined (function #{fa} is not available)"
+    "undefined function " <> Exception.format_mfa(module, function, arity) <>
+      " (function #{fa} is not available)"
   end
 
   def message(%{reason: reason,  module: module, function: function, arity: arity}) do
-    "function " <> Exception.format_mfa(module, function, arity) <> " is undefined (#{reason})"
-  end
-
-  @doc false
-  def function_not_exported(module, function, arity, exports) do
-    suffix =
-      if macro_exported?(module, function, arity) do
-        ". However there is a macro with the same name and arity. " <>
-          "Be sure to require #{inspect(module)} if you intend to invoke this macro"
-      else
-        did_you_mean(module, function, exports)
-      end
-
-    ["function ", Exception.format_mfa(module, function, arity), " is undefined or private", suffix]
-  end
-
-  @function_threshold 0.77
-  @max_suggestions 5
-
-  defp did_you_mean(module, function, exports) do
-    exports = exports || exports_for(module)
-
-    result =
-      case Keyword.take(exports, [function]) do
-        [] ->
-          base = Atom.to_string(function)
-          for {key, val} <- exports,
-              dist = String.jaro_distance(base, Atom.to_string(key)),
-              dist >= @function_threshold,
-            do: {dist, key, val}
-        arities ->
-          for {key, val} <- arities, do: {1.0, key, val}
-      end
-      |> Enum.sort(&elem(&1, 0) >= elem(&2, 0))
-      |> Enum.take(@max_suggestions)
-      |> Enum.sort(&elem(&1, 1) <= elem(&2, 1))
-
-    case result do
-      []          -> []
-      suggestions -> [". Did you mean one of:\n\n" | Enum.map(suggestions, &format_fa/1)]
-    end
-  end
-
-  defp format_fa({_dist, fun, arity}) do
-    ["      * ", Inspect.Function.escape_name(fun), ?/, Integer.to_string(arity), ?\n]
-  end
-
-  defp exports_for(module) do
-    if function_exported?(module, :__info__, 1) do
-      module.__info__(:macros) ++ module.__info__(:functions)
-    else
-      module.module_info(:exports)
-    end
-  rescue
-    # In case the module was removed while we are computing this
-    UndefinedFunctionError -> []
+    "undefined function " <> Exception.format_mfa(module, function, arity) <> " (#{reason})"
   end
 end
 
 defmodule FunctionClauseError do
-  defexception [:module, :function, :arity, :kind, :args, :clauses]
+  defexception [module: nil, function: nil, arity: nil]
 
   def message(exception) do
-    case exception do
-      %{function: nil} ->
-        "no function clause matches"
-      %{module: module, function: function, arity: arity} ->
-        formatted = Exception.format_mfa module, function, arity
-        "no function clause matching in #{formatted}" <> blame(exception, &inspect/1, &blame_match/2)
+    if exception.function do
+      formatted = Exception.format_mfa exception.module, exception.function, exception.arity
+      "no function clause matching in #{formatted}"
+    else
+      "no function clause matches"
     end
   end
-
-  defp blame_match(%{match?: true, node: node}, _),
-    do: Macro.to_string(node)
-  defp blame_match(%{match?: false, node: node}, _),
-    do: "-" <> Macro.to_string(node) <> "-"
-  defp blame_match(_, string),
-    do: string
-
-  @doc false
-  def blame(%{args: nil}, _, _) do
-    ""
-  end
-  def blame(%{module: module, function: function, arity: arity,
-              kind: kind, args: args, clauses: clauses}, inspect_fun, ast_fun) do
-    mfa = Exception.format_mfa(module, function, arity)
-
-    formatted_args =
-      args
-      |> Enum.with_index(1)
-      |> Enum.map(fn {arg, i} -> "\n    # #{i}\n    #{inspect_fun.(arg)}\n" end)
-
-    formatted_clauses =
-      if clauses do
-        top_10 =
-          clauses
-          |> Enum.take(10)
-          |> Enum.map(fn {args, guards} ->
-            code = Enum.reduce(guards, {function, [], args}, &{:when, [], [&2, &1]})
-            "    #{kind} " <> Macro.to_string(code, ast_fun) <> "\n"
-          end)
-
-        "\nAttempted function clauses (showing #{length(top_10)} out of #{length(clauses)}):\n\n#{top_10}"
-      else
-        ""
-      end
-
-    "\n\nThe following arguments were given to #{mfa}:\n#{formatted_args}#{formatted_clauses}"
-  end
 end
 
 defmodule Code.LoadError do
@@ -939,30 +669,20 @@ defmodule Code.LoadError do
 end
 
 defmodule Protocol.UndefinedError do
-  defexception [:protocol, :value, description: ""]
+  defexception [protocol: nil, value: nil, description: nil]
 
-  def message(%{protocol: protocol, value: value, description: description}) do
-    "protocol #{inspect protocol} not implemented for #{inspect value}" <>
-      maybe_description(description) <> maybe_available(protocol)
-  end
-
-  defp maybe_description(""), do: ""
-  defp maybe_description(description), do: ", " <> description
-
-  defp maybe_available(protocol) do
-    case protocol.__protocol__(:impls) do
-      {:consolidated, []} ->
-        ". There are no implementations for this protocol."
-      {:consolidated, types} ->
-        ". This protocol is implemented for: #{Enum.map_join(types, ", ", &inspect/1)}"
-      :not_consolidated ->
-        ""
+  def message(exception) do
+    msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.value}"
+    if exception.description do
+      msg <> ", " <> exception.description
+    else
+      msg
     end
   end
 end
 
 defmodule KeyError do
-  defexception [:key, :term]
+  defexception key: nil, term: nil
 
   def message(exception) do
     msg = "key #{inspect exception.key} not found"
@@ -988,73 +708,56 @@ defmodule UnicodeConversionError do
     "encoding starting at #{inspect rest}"
   end
 
-  defp detail([h | _]) when is_integer(h) do
+  defp detail([h|_]) when is_integer(h) do
     "code point #{h}"
   end
 
-  defp detail([h | _]) do
+  defp detail([h|_]) do
     detail(h)
   end
 end
 
 defmodule Enum.OutOfBoundsError do
-  defexception message: "out of bounds error"
+  defexception []
+
+  def message(_) do
+    "out of bounds error"
+  end
 end
 
 defmodule Enum.EmptyError do
-  defexception message: "empty error"
+  defexception []
+
+  def message(_) do
+    "empty error"
+  end
 end
 
 defmodule File.Error do
-  defexception [:reason, :path, action: ""]
+  defexception [reason: nil, action: "", path: nil]
 
-  def message(%{action: action, reason: reason, path: path}) do
-    formatted =
-      case {action, reason} do
-        {"remove directory", :eexist} ->
-          "directory is not empty"
-        _ ->
-          IO.iodata_to_binary(:file.format_error(reason))
-      end
-
-    "could not #{action} #{inspect(path)}: #{formatted}"
+  def message(exception) do
+    formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
+    "could not #{exception.action} #{exception.path}: #{formatted}"
   end
 end
 
 defmodule File.CopyError do
-  defexception [:reason, :source, :destination, on: "", action: ""]
+  defexception [reason: nil, action: "", source: nil, destination: nil, on: nil]
 
   def message(exception) do
-    formatted =
-      IO.iodata_to_binary(:file.format_error(exception.reason))
-
-    location =
-      case exception.on do
-        "" -> ""
-        on -> ". #{on}"
-      end
-
-    "could not #{exception.action} from #{inspect(exception.source)} to " <>
-      "#{inspect(exception.destination)}#{location}: #{formatted}"
-  end
-end
-
-defmodule File.LinkError do
-  defexception [:reason, :existing, :new, action: ""]
-
-  def message(exception) do
-    formatted =
-      IO.iodata_to_binary(:file.format_error(exception.reason))
-    "could not #{exception.action} from #{inspect(exception.existing)} to " <>
-      "#{inspect(exception.new)}: #{formatted}"
+    formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
+    location  = if on = exception.on, do: ". #{on}", else: ""
+    "could not #{exception.action} from #{exception.source} to " <>
+      "#{exception.destination}#{location}: #{formatted}"
   end
 end
 
 defmodule ErlangError do
-  defexception [:original]
+  defexception [original: nil]
 
   def message(exception) do
-    "Erlang error: #{inspect(exception.original)}"
+    "erlang error: #{inspect(exception.original)}"
   end
 
   @doc false
@@ -1094,17 +797,13 @@ defmodule ErlangError do
     %BadMapError{term: term}
   end
 
-  def normalize({:badbool, op, term}, _stacktrace) do
-    %BadBooleanError{operator: op, term: term}
-  end
-
   def normalize({:badkey, key}, stacktrace) do
     term =
-      case ensure_stacktrace(stacktrace) do
-        [{Map, :get_and_update!, [map, _, _], _} | _] -> map
-        [{Map, :update!, [map, _, _], _} | _] -> map
-        [{:maps, :update, [_, _, map], _} | _] -> map
-        [{:maps, :get, [_, map], _} | _] -> map
+      case stacktrace || :erlang.get_stacktrace do
+        [{Map, :get_and_update!, [map, _, _], _}|_] -> map
+        [{Map, :update!, [map, _, _], _}|_] -> map
+        [{:maps, :update, [_, _, map], _}|_] -> map
+        [{:maps, :get, [_, map], _}|_] -> map
         _ -> nil
       end
     %KeyError{key: key, term: term}
@@ -1118,22 +817,18 @@ defmodule ErlangError do
     %CaseClauseError{term: term}
   end
 
-  def normalize({:with_clause, term}, _stacktrace) do
-    %WithClauseError{term: term}
-  end
-
   def normalize({:try_clause, term}, _stacktrace) do
     %TryClauseError{term: term}
   end
 
   def normalize(:undef, stacktrace) do
-    stacktrace = ensure_stacktrace(stacktrace)
+    stacktrace = stacktrace || :erlang.get_stacktrace
     {mod, fun, arity} = from_stacktrace(stacktrace)
     %UndefinedFunctionError{module: mod, function: fun, arity: arity}
   end
 
   def normalize(:function_clause, stacktrace) do
-    {mod, fun, arity} = from_stacktrace(ensure_stacktrace(stacktrace))
+    {mod, fun, arity} = from_stacktrace(stacktrace || :erlang.get_stacktrace)
     %FunctionClauseError{module: mod, function: fun, arity: arity}
   end
 
@@ -1145,23 +840,11 @@ defmodule ErlangError do
     %ErlangError{original: other}
   end
 
-  defp ensure_stacktrace(nil) do
-    try do
-      :erlang.get_stacktrace()
-    rescue
-      _ -> []
-    end
-  end
-
-  defp ensure_stacktrace(stacktrace) do
-    stacktrace
-  end
-
-  defp from_stacktrace([{module, function, args, _} | _]) when is_list(args) do
+  defp from_stacktrace([{module, function, args, _}|_]) when is_list(args) do
     {module, function, length(args)}
   end
 
-  defp from_stacktrace([{module, function, arity, _} | _]) do
+  defp from_stacktrace([{module, function, arity, _}|_]) do
     {module, function, arity}
   end
 

lib/elixir/lib/file.ex

@@ -10,12 +10,6 @@ defmodule File do
   via `cp/3` and remove files and directories recursively
   via `rm_rf/1`.
 
-  Paths given to functions in this module can be either relative to the
-  current working directory (as returned by `File.cwd/0`), or absolute
-  paths. Shell conventions like `~` are not expanded automatically.
-  To use paths like `~/Downloads`, you can use `Path.expand/1` or
-  `Path.expand/2` to expand your path to an absolute path.
-
   ## Encoding
 
   In order to write and read files, one must use the functions
@@ -26,7 +20,7 @@ defmodule File do
   `IO.write/2` functions must be used as they are responsible for
   doing the proper conversions and providing the proper data guarantees.
 
-  Note that filenames when given as charlists in Elixir are
+  Note that filenames when given as char lists in Elixir are
   always treated as UTF-8. In particular, we expect that the
   shell and the operating system are configured to use UTF-8
   encoding. Binary filenames are considered raw and passed
@@ -76,12 +70,14 @@ defmodule File do
   about such options and other performance considerations.
   """
 
+  alias :file, as: F
+
   @type posix :: :file.posix()
   @type io_device :: :file.io_device()
   @type stat_options :: [time: :local | :universal | :posix]
-  @type mode :: :append | :binary | :charlist | :compressed | :delayed_write | :exclusive |
-    :raw | :read | :read_ahead | :sync | :utf8 | :write |
-    {:encoding, :latin1 | :unicode | :utf8 | :utf16 | :utf32 |
+  @type mode :: :append | :binary | :compressed | :delayed_write | :exclusive |
+    :raw | :read | :read_ahead | :sync | :write |
+    {:encoding, :latin1 | :unicode | :utf16 | :utf32 | :utf8 |
       {:utf16, :big | :little} | {:utf32, :big | :little}} |
     {:read_ahead, pos_integer} |
     {:delayed_write, non_neg_integer, non_neg_integer}
@@ -89,9 +85,6 @@ defmodule File do
   @doc """
   Returns `true` if the path is a regular file.
 
-  This function follows symbolic links, so if a symbolic link points to a
-  regular file, `true` is returned.
-
   ## Examples
 
       File.regular? __ENV__.file #=> true
@@ -103,28 +96,7 @@ defmodule File do
   end
 
   @doc """
-  Returns `true` if the given path is a directory.
-
-  This function follows symbolic links, so if a symbolic link points to a
-  directory, `true` is returned.
-
-  ## Examples
-
-      File.dir?("./test")
-      #=> true
-
-      File.dir?("test")
-      #=> true
-
-      File.dir?("/usr/bin")
-      #=> true
-
-      File.dir?("~/Downloads")
-      #=> false
-
-      "~/Downloads" |> Path.expand |> File.dir?
-      #=> true
-
+  Returns `true` if the path is a directory.
   """
   @spec dir?(Path.t) :: boolean
   def dir?(path) do
@@ -150,7 +122,7 @@ defmodule File do
   """
   @spec exists?(Path.t) :: boolean
   def exists?(path) do
-    match?({:ok, _}, :file.read_file_info(IO.chardata_to_string(path)))
+    match?({:ok, _}, F.read_file_info(IO.chardata_to_string(path)))
   end
 
   @doc """
@@ -163,13 +135,13 @@ defmodule File do
       directories of `path`
     * `:eexist`  - there is already a file or directory named `path`
     * `:enoent`  - a component of `path` does not exist
-    * `:enospc`  - there is no space left on the device
+    * `:enospc`  - there is a no space left on the device
     * `:enotdir` - a component of `path` is not a directory;
       on some platforms, `:enoent` is returned instead
   """
   @spec mkdir(Path.t) :: :ok | {:error, posix}
   def mkdir(path) do
-    :file.make_dir(IO.chardata_to_string(path))
+    F.make_dir(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -193,7 +165,7 @@ defmodule File do
 
     * `:eacces`  - missing search or write permissions for the parent
       directories of `path`
-    * `:enospc`  - there is no space left on the device
+    * `:enospc`  - there is a no space left on the device
     * `:enotdir` - a component of `path` is not a directory
   """
   @spec mkdir_p(Path.t) :: :ok | {:error, posix}
@@ -215,7 +187,7 @@ defmodule File do
         {:error, :einval}
       else
         _ = do_mkdir_p(parent)
-        case :file.make_dir(path) do
+        case F.make_dir(path) do
           {:error, :eexist} = error ->
             if dir?(path), do: :ok, else: error
           other ->
@@ -256,7 +228,7 @@ defmodule File do
   """
   @spec read(Path.t) :: {:ok, binary} | {:error, posix}
   def read(path) do
-    :file.read_file(IO.chardata_to_string(path))
+    F.read_file(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -297,7 +269,7 @@ defmodule File do
   @spec stat(Path.t, stat_options) :: {:ok, File.Stat.t} | {:error, posix}
   def stat(path, opts \\ []) do
     opts = Keyword.put_new(opts, :time, :universal)
-    case :file.read_file_info(IO.chardata_to_string(path), opts) do
+    case F.read_file_info(IO.chardata_to_string(path), opts) do
       {:ok, fileinfo} ->
         {:ok, File.Stat.from_record(fileinfo)}
       error ->
@@ -306,7 +278,7 @@ defmodule File do
   end
 
   @doc """
-  Same as `stat/2` but returns the `File.Stat` directly, or
+  Same as `stat/2` but returns the `File.Stat` directly and
   throws `File.Error` if an error is returned.
   """
   @spec stat!(Path.t, stat_options) :: File.Stat.t | no_return
@@ -342,7 +314,7 @@ defmodule File do
   @spec lstat(Path.t, stat_options) :: {:ok, File.Stat.t} | {:error, posix}
   def lstat(path, opts \\ []) do
     opts = Keyword.put_new(opts, :time, :universal)
-    case :file.read_link_info(IO.chardata_to_string(path), opts) do
+    case F.read_link_info(IO.chardata_to_string(path), opts) do
       {:ok, fileinfo} ->
         {:ok, File.Stat.from_record(fileinfo)}
       error ->
@@ -351,7 +323,7 @@ defmodule File do
   end
 
   @doc """
-  Same as `lstat/2` but returns the `File.Stat` struct directly, or
+  Same as `lstat/2` but returns the `File.Stat` struct directly and
   throws `File.Error` if an error is returned.
   """
   @spec lstat!(Path.t, stat_options) :: File.Stat.t | no_return
@@ -364,44 +336,6 @@ defmodule File do
     end
   end
 
-  @doc """
-  Reads the symbolic link at `path`.
-
-  If `path` exists and is a symlink, returns `{:ok, target}`, otherwise returns
-  `{:error, reason}`.
-
-  For more details, see
-  [`:file.read_link/1`](http://erlang.org/doc/man/file.html#read_link-1).
-
-  Typical error reasons are:
-
-    * `:einval` - path is not a symbolic link
-    * `:enoent` - path does not exist
-    * `:enotsup` - symbolic links are not supported on the current platform
-
-  """
-  @spec read_link(Path.t) :: {:ok, binary} | {:error, posix}
-  def read_link(path) do
-    case path |> IO.chardata_to_string |> :file.read_link do
-      {:ok, target} -> {:ok, IO.chardata_to_string(target)}
-      error -> error
-    end
-  end
-
-  @doc """
-  Same as `read_link/1` but returns the target directly or throws `File.Error` if an error is
-  returned.
-  """
-  @spec read_link!(Path.t) :: binary | no_return
-  def read_link!(path) do
-    case read_link(path) do
-      {:ok, resolved} ->
-        resolved
-      {:error, reason} ->
-        raise File.Error, reason: reason, action: "read link", path: IO.chardata_to_string(path)
-    end
-  end
-
   @doc """
   Writes the given `File.Stat` back to the filesystem at the given
   path. Returns `:ok` or `{:error, reason}`.
@@ -409,7 +343,7 @@ defmodule File do
   @spec write_stat(Path.t, File.Stat.t, stat_options) :: :ok | {:error, posix}
   def write_stat(path, stat, opts \\ []) do
     opts = Keyword.put_new(opts, :time, :universal)
-    :file.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)
+    F.write_file_info(IO.chardata_to_string(path), File.Stat.to_record(stat), opts)
   end
 
   @doc """
@@ -463,32 +397,6 @@ defmodule File do
     end
   end
 
-  @doc """
-  Creates a hard link `new` to the file `existing`.
-
-  Returns `:ok` if successful, `{:error, reason}` otherwise.
-  If the operating system does not support hard links, returns
-  `{:error, :enotsup}`.
-  """
-  def ln(existing, new) do
-    :file.make_link(IO.chardata_to_string(existing), IO.chardata_to_string(new))
-  end
-
-  @doc """
-  Same as `ln/2` but raises an exception if it fails.
-
-  Returns `:ok` otherwise
-  """
-  def ln!(existing, new) do
-    case ln(existing, new) do
-      :ok -> :ok
-      {:error, reason} ->
-        raise File.LinkError, reason: reason, action: "create hard link",
-          existing: IO.chardata_to_string(existing),
-          new: IO.chardata_to_string(new)
-    end
-  end
-
   @doc """
   Creates a symbolic link `new` to the file or directory `existing`.
 
@@ -497,28 +405,13 @@ defmodule File do
   `{:error, :enotsup}`.
   """
   def ln_s(existing, new) do
-    :file.make_symlink(IO.chardata_to_string(existing), IO.chardata_to_string(new))
-  end
-
-  @doc """
-  Same as `ln_s/2` but raises an exception if it fails.
-
-  Returns `:ok` otherwise
-  """
-  def ln_s!(existing, new) do
-    case ln_s(existing, new) do
-      :ok -> :ok
-      {:error, reason} ->
-        raise File.LinkError, reason: reason, action: "create symlink",
-          existing: IO.chardata_to_string(existing),
-          new: IO.chardata_to_string(new)
-    end
+    F.make_symlink(existing, new)
   end
 
   @doc """
   Copies the contents of `source` to `destination`.
 
-  Both parameters can be a filename or an IO device opened
+  Both parameters can be a filename or an io device opened
   with `open/2`. `bytes_count` specifies the number of
   bytes to copy, the default being `:infinity`.
 
@@ -537,23 +430,22 @@ defmodule File do
   Typical error reasons are the same as in `open/2`,
   `read/1` and `write/3`.
   """
-  @spec copy(Path.t | io_device, Path.t | io_device, pos_integer | :infinity) :: {:ok, non_neg_integer} | {:error, posix}
+  @spec copy(Path.t, Path.t, pos_integer | :infinity) :: {:ok, non_neg_integer} | {:error, posix}
   def copy(source, destination, bytes_count \\ :infinity) do
-    :file.copy(maybe_to_string(source), maybe_to_string(destination), bytes_count)
+    F.copy(IO.chardata_to_string(source), IO.chardata_to_string(destination), bytes_count)
   end
 
   @doc """
   The same as `copy/3` but raises an `File.CopyError` if it fails.
   Returns the `bytes_copied` otherwise.
   """
-  @spec copy!(Path.t | io_device, Path.t | io_device, pos_integer | :infinity) :: non_neg_integer | no_return
+  @spec copy!(Path.t, Path.t, pos_integer | :infinity) :: non_neg_integer | no_return
   def copy!(source, destination, bytes_count \\ :infinity) do
     case copy(source, destination, bytes_count) do
       {:ok, bytes_count} -> bytes_count
       {:error, reason} ->
         raise File.CopyError, reason: reason, action: "copy",
-          source: maybe_to_string(source),
-          destination: maybe_to_string(destination)
+          source: IO.chardata_to_string(source), destination: IO.chardata_to_string(destination)
     end
   end
 
@@ -563,7 +455,7 @@ defmodule File do
   specify the `destination` filename, it is not sufficient to simply specify
   its directory.
 
-  Returns `:ok` in case of success, `{:error, reason}` otherwise.
+  It returns `:ok` in case of success, returns `{:error, reason}` otherwise.
 
   Note: The command `mv` in Unix systems behaves differently depending
   if `source` is a file and the `destination` is an existing directory.
@@ -579,7 +471,7 @@ defmodule File do
   """
   @spec rename(Path.t, Path.t) :: :ok | {:error, posix}
   def rename(source, destination) do
-    :file.rename(source, destination)
+    F.rename(source, destination)
   end
 
   @doc """
@@ -592,7 +484,7 @@ defmodule File do
   The function returns `:ok` in case of success, returns
   `{:error, reason}` otherwise.
 
-  If you want to copy contents from an IO device to another device
+  If you want to copy contents from an io device to another device
   or do a straight copy from a source to a destination without
   preserving modes, check `copy/3` instead.
 
@@ -640,9 +532,10 @@ defmodule File do
   `destination`. If the source is a directory, it copies
   the contents inside source into the destination.
 
-  If a file already exists in the destination, it invokes `callback`.
-  `callback` must be a function that takes two arguments: `source` and `destination`.
-  The callback should return `true` if the existing file should be overwritten and `false` otherwise.
+  If a file already exists in the destination,
+  it invokes a callback which should return
+  `true` if the existing file should be overwritten,
+  `false` otherwise. The callback defaults to return `true`.
 
   If a directory already exists in the destination
   where a file is meant to be (or vice versa), this
@@ -670,21 +563,15 @@ defmodule File do
       File.cp_r "samples", "tmp"
 
       # Same as before, but asks the user how to proceed in case of conflicts
-      File.cp_r "samples", "tmp", fn source, destination ->
+      File.cp_r "samples", "tmp", fn(source, destination) ->
         IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
       end
 
   """
   @spec cp_r(Path.t, Path.t, (Path.t, Path.t -> boolean)) :: {:ok, [binary]} | {:error, posix, binary}
-  def cp_r(source, destination, callback \\ fn _, _ -> true end) when is_function(callback, 2) do
-    source =
-      source
-      |> IO.chardata_to_string()
-      |> assert_no_null_byte!("File.cp_r/3")
-    destination =
-      destination
-      |> IO.chardata_to_string()
-      |> assert_no_null_byte!("File.cp_r/3")
+  def cp_r(source, destination, callback \\ fn(_, _) -> true end) when is_function(callback) do
+    source = IO.chardata_to_string(source)
+    destination = IO.chardata_to_string(destination)
 
     case do_cp_r(source, destination, callback, []) do
       {:error, _, _} = error -> error
@@ -713,16 +600,16 @@ defmodule File do
       {:ok, :regular} ->
         do_cp_file(src, dest, callback, acc)
       {:ok, :symlink} ->
-        case :file.read_link(src) do
+        case F.read_link(src) do
           {:ok, link} -> do_cp_link(link, src, dest, callback, acc)
           {:error, reason} -> {:error, reason, src}
         end
       {:ok, :directory} ->
-        case :file.list_dir(src) do
+        case F.list_dir(src) do
           {:ok, files} ->
             case mkdir(dest) do
               success when success in [:ok, {:error, :eexist}] ->
-                Enum.reduce(files, [dest | acc], fn(x, acc) ->
+                Enum.reduce(files, [dest|acc], fn(x, acc) ->
                   do_cp_r(Path.join(src, x), Path.join(dest, x), callback, acc)
                 end)
               {:error, reason} -> {:error, reason, dest}
@@ -746,16 +633,16 @@ defmodule File do
 
   # Both src and dest are files.
   defp do_cp_file(src, dest, callback, acc) do
-    case :file.copy(src, {dest, [:exclusive]}) do
+    case F.copy(src, {dest, [:exclusive]}) do
       {:ok, _} ->
         copy_file_mode!(src, dest)
-        [dest | acc]
+        [dest|acc]
       {:error, :eexist} ->
         if path_differs?(src, dest) and callback.(src, dest) do
           case copy(src, dest) do
             {:ok, _} ->
               copy_file_mode!(src, dest)
-              [dest | acc]
+              [dest|acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
@@ -767,15 +654,15 @@ defmodule File do
 
   # Both src and dest are files.
   defp do_cp_link(link, src, dest, callback, acc) do
-    case :file.make_symlink(link, dest) do
+    case F.make_symlink(link, dest) do
       :ok ->
-        [dest | acc]
+        [dest|acc]
       {:error, :eexist} ->
         if path_differs?(src, dest) and callback.(src, dest) do
-          # If rm/1 fails, :file.make_symlink/2 will fail
+          # If rm/1 fails, F.make_symlink/2 will fail
           _ = rm(dest)
-          case :file.make_symlink(link, dest) do
-            :ok -> [dest | acc]
+          case F.make_symlink(link, dest) do
+            :ok -> [dest|acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
@@ -792,9 +679,6 @@ defmodule File do
   contents are overwritten. Returns `:ok` if successful, or `{:error, reason}`
   if an error occurs.
 
-  `content` must be `iodata` (a list of bytes or a binary). Setting the
-  encoding for this function has no effect.
-
   **Warning:** Every time this function is invoked, a file descriptor is opened
   and a new process is spawned to write to the file. For this reason, if you are
   doing multiple writes in a loop, opening the file via `File.open/2` and using
@@ -806,7 +690,7 @@ defmodule File do
     * `:enoent`  - a component of the file name does not exist
     * `:enotdir` - a component of the file name is not a directory;
       on some platforms, `:enoent` is returned instead
-    * `:enospc`  - there is no space left on the device
+    * `:enospc`  - there is a no space left on the device
     * `:eacces`  - missing permission for writing the file or searching one of
       the parent directories
     * `:eisdir`  - the named file is a directory
@@ -815,8 +699,7 @@ defmodule File do
   """
   @spec write(Path.t, iodata, [mode]) :: :ok | {:error, posix}
   def write(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
-    :file.write_file(IO.chardata_to_string(path), content, modes)
+    F.write_file(IO.chardata_to_string(path), content, modes)
   end
 
   @doc """
@@ -824,8 +707,7 @@ defmodule File do
   """
   @spec write!(Path.t, iodata, [mode]) :: :ok | no_return
   def write!(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
-    case :file.write_file(path, content, modes) do
+    case F.write_file(path, content, modes) do
       :ok -> :ok
       {:error, reason} ->
         raise File.Error, reason: reason, action: "write to file",
@@ -861,7 +743,7 @@ defmodule File do
   @spec rm(Path.t) :: :ok | {:error, posix}
   def rm(path) do
     path = IO.chardata_to_string(path)
-    case :file.delete(path) do
+    case F.delete(path) do
       :ok ->
         :ok
       {:error, :eacces} = e ->
@@ -873,7 +755,7 @@ defmodule File do
 
   defp change_mode_windows(path) do
     if match? {:win32, _}, :os.type do
-      case :file.read_file_info(path) do
+      case F.read_file_info(path) do
         {:ok, file_info} when elem(file_info, 3) in [:read, :none] ->
           change_mode_windows(path, file_info)
         _ ->
@@ -884,7 +766,7 @@ defmodule File do
 
   defp change_mode_windows(path, file_info) do
     case chmod(path, (elem(file_info, 7) + 0o200)) do
-      :ok -> :file.delete(path)
+      :ok -> F.delete(path)
       {:error, _reason} = error -> error
     end
   end
@@ -917,7 +799,7 @@ defmodule File do
   """
   @spec rmdir(Path.t) :: :ok | {:error, posix}
   def rmdir(path) do
-    :file.del_dir(IO.chardata_to_string(path))
+    F.del_dir(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -953,10 +835,7 @@ defmodule File do
   """
   @spec rm_rf(Path.t) :: {:ok, [binary]} | {:error, posix, binary}
   def rm_rf(path) do
-    path
-    |> IO.chardata_to_string()
-    |> assert_no_null_byte!("File.rm_rf/1")
-    |> do_rm_rf({:ok, []})
+    do_rm_rf(IO.chardata_to_string(path), {:ok, []})
   end
 
   defp do_rm_rf(path, {:ok, _} = entry) do
@@ -970,7 +849,7 @@ defmodule File do
         case res do
           {:ok, acc} ->
             case rmdir(path) do
-              :ok -> {:ok, [path | acc]}
+              :ok -> {:ok, [path|acc]}
               {:error, :enoent} -> res
               {:error, reason} -> {:error, reason, path}
             end
@@ -990,19 +869,19 @@ defmodule File do
 
   defp do_rm_regular(path, {:ok, acc} = entry) do
     case rm(path) do
-      :ok -> {:ok, [path | acc]}
+      :ok -> {:ok, [path|acc]}
       {:error, :enoent} -> entry
       {:error, reason} -> {:error, reason, path}
     end
   end
 
-  # On Windows, symlinks are treated as directory and must be removed
+  # On windows, symlinks are treated as directory and must be removed
   # with rmdir/1. But on Unix, we remove them via rm/1. So we first try
   # to remove it as a directory and, if we get :enotdir, we fallback to
   # a file removal.
   defp do_rm_directory(path, {:ok, acc} = entry) do
     case rmdir(path) do
-      :ok -> {:ok, [path | acc]}
+      :ok -> {:ok, [path|acc]}
       {:error, :enotdir} -> do_rm_regular(path, entry)
       {:error, :enoent} -> entry
       {:error, reason} -> {:error, reason, path}
@@ -1017,7 +896,7 @@ defmodule File do
           _ -> {:ok, :regular}
         end
       {:ok, :directory} ->
-        :file.list_dir(path)
+        F.list_dir(path)
       {:ok, _} ->
         {:ok, :regular}
       {:error, reason} ->
@@ -1040,26 +919,17 @@ defmodule File do
   end
 
   @doc ~S"""
-  Opens the given `path`.
+  Opens the given `path` according to the given list of modes.
 
   In order to write and read files, one must use the functions
-  in the `IO` module. By default, a file is opened in `:binary` mode,
+  in the `IO` module. By default, a file is opened in binary mode,
   which requires the functions `IO.binread/2` and `IO.binwrite/2`
   to interact with the file. A developer may pass `:utf8` as an
   option when opening the file and then all other functions from
   `IO` are available, since they work directly with Unicode data.
 
-  `modes_or_function` can either be a list of modes or a function. If it's a
-  list, it's considered to be a list of modes (that are documented below). If
-  it's a function, then it's equivalent to calling `open(path, [],
-  modes_or_function)`. See the documentation for `open/3` for more information
-  on this function.
-
   The allowed modes:
 
-    * `:binary` - opens the file in binary mode, disabling special handling of unicode sequences
-      (default mode).
-
     * `:read` - the file, which must exist, is opened for reading.
 
     * `:write` - the file is opened for writing. It is created if it does not
@@ -1075,8 +945,8 @@ defmodule File do
     * `:exclusive` - the file, when opened for writing, is created if it does
       not exist. If the file exists, open will return `{:error, :eexist}`.
 
-    * `:charlist` - when this term is given, read operations on the file will
-      return charlists rather than binaries.
+    * `:char_list` - when this term is given, read operations on the file will
+      return char lists rather than binaries.
 
     * `:compressed` - makes it possible to read or write gzip compressed files.
 
@@ -1093,15 +963,14 @@ defmodule File do
       cannot cope with the character range of the data, an error occurs and the
       file will be closed.
 
-    * `:delayed_write`, `:raw`, `:ram`, `:read_ahead`, `:sync`, `{:encoding, ...}`,
-      `{:read_ahead, pos_integer}`, `{:delayed_write, non_neg_integer, non_neg_integer}` -
-      for more information about these options see [`:file.open/2`](http://www.erlang.org/doc/man/file.html#open-2).
+  For more information about other options like `:read_ahead` and `:delayed_write`,
+  see [`:file.open/2`](http://www.erlang.org/doc/man/file.html#open-2).
 
   This function returns:
 
     * `{:ok, io_device}` - the file has been opened in the requested mode.
 
-      `io_device` is actually the PID of the process which handles the file.
+      `io_device` is actually the pid of the process which handles the file.
       This process is linked to the process which originally opened the file.
       If any process to which the `io_device` is linked terminates, the file
       will be closed and the process itself will be terminated.
@@ -1120,13 +989,13 @@ defmodule File do
   """
   @spec open(Path.t, [mode | :ram]) :: {:ok, io_device} | {:error, posix}
   @spec open(Path.t, (io_device -> res)) :: {:ok, res} | {:error, posix} when res: var
-  def open(path, modes_or_function \\ [])
+  def open(path, modes \\ [])
 
   def open(path, modes) when is_list(modes) do
-    :file.open(IO.chardata_to_string(path), normalize_modes(modes, true))
+    F.open(IO.chardata_to_string(path), open_defaults(modes, true))
   end
 
-  def open(path, function) when is_function(function, 1) do
+  def open(path, function) when is_function(function) do
     open(path, [], function)
   end
 
@@ -1137,7 +1006,7 @@ defmodule File do
   automatically closed after the function returns, regardless
   if there was an error when executing the function.
 
-  Returns `{:ok, function_result}` in case of success,
+  It returns `{:ok, function_result}` in case of success,
   `{:error, reason}` otherwise.
 
   This function expects the file to be closed with success,
@@ -1151,51 +1020,43 @@ defmodule File do
         IO.read(file, :line)
       end)
 
-  See `open/2` for the list of available `modes`.
   """
   @spec open(Path.t, [mode | :ram], (io_device -> res)) :: {:ok, res} | {:error, posix} when res: var
-  def open(path, modes, function) when is_list(modes) and is_function(function, 1) do
+  def open(path, modes, function) do
     case open(path, modes) do
-      {:ok, io_device} ->
+      {:ok, device} ->
         try do
-          {:ok, function.(io_device)}
+          {:ok, function.(device)}
         after
-          :ok = close(io_device)
+          :ok = close(device)
         end
       other -> other
     end
   end
 
   @doc """
-  Similar to `open/2` but raises an error if file could not be opened.
+  Same as `open/2` but raises an error if file could not be opened.
 
-  Returns the IO device otherwise.
-
-  See `open/2` for the list of available modes.
+  Returns the `io_device` otherwise.
   """
-  @spec open!(Path.t, [mode | :ram]) :: io_device | no_return
-  @spec open!(Path.t, (io_device -> res)) :: res | no_return when res: var
-  def open!(path, modes_or_function \\ []) do
-    case open(path, modes_or_function) do
-      {:ok, io_device_or_function_result} ->
-        io_device_or_function_result
+  @spec open!(Path.t, [mode]) :: io_device | no_return
+  def open!(path, modes \\ []) do
+    case open(path, modes) do
+      {:ok, device}    -> device
       {:error, reason} ->
         raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
     end
   end
 
   @doc """
-  Similar to `open/3` but raises an error if file could not be opened.
+  Same as `open/3` but raises an error if file could not be opened.
 
-  If it succeeds opening the file, it returns the `function` result on the IO device.
-
-  See `open/2` for the list of available `modes`.
+  Returns the function result otherwise.
   """
   @spec open!(Path.t, [mode | :ram], (io_device -> res)) :: res | no_return when res: var
   def open!(path, modes, function) do
     case open(path, modes, function) do
-      {:ok, function_result} ->
-        function_result
+      {:ok, device}    -> device
       {:error, reason} ->
         raise File.Error, reason: reason, action: "open", path: IO.chardata_to_string(path)
     end
@@ -1211,7 +1072,7 @@ defmodule File do
   """
   @spec cwd() :: {:ok, binary} | {:error, posix}
   def cwd() do
-    case :file.get_cwd do
+    case F.get_cwd do
       {:ok, base} -> {:ok, IO.chardata_to_string(fix_drive_letter(base))}
       {:error, _} = error -> error
     end
@@ -1219,7 +1080,7 @@ defmodule File do
 
   defp fix_drive_letter([l, ?:, ?/ | rest] = original) when l in ?A..?Z do
     case :os.type() do
-      {:win32, _} -> [l + ?a - ?A, ?:, ?/ | rest]
+      {:win32, _} -> [l+?a-?A, ?:, ?/ | rest]
       _ -> original
     end
   end
@@ -1245,7 +1106,7 @@ defmodule File do
   """
   @spec cd(Path.t) :: :ok | {:error, posix}
   def cd(path) do
-    :file.set_cwd(IO.chardata_to_string(path))
+    F.set_cwd(IO.chardata_to_string(path))
   end
 
   @doc """
@@ -1269,9 +1130,9 @@ defmodule File do
   Raises an error if retrieving or changing the current
   directory fails.
   """
-  @spec cd!(Path.t, (() -> res)) :: res when res: var
+  @spec cd!(Path.t, (() -> res)) :: res | no_return when res: var
   def cd!(path, function) do
-    old = cwd!()
+    old = cwd!
     cd!(path)
     try do
       function.()
@@ -1283,12 +1144,12 @@ defmodule File do
   @doc """
   Returns the list of files in the given directory.
 
-  Returns `{:ok, [files]}` in case of success,
+  It returns `{:ok, [files]}` in case of success,
   `{:error, reason}` otherwise.
   """
   @spec ls(Path.t) :: {:ok, [binary]} | {:error, posix}
   def ls(path \\ ".") do
-    case :file.list_dir(IO.chardata_to_string(path)) do
+    case F.list_dir(IO.chardata_to_string(path)) do
       {:ok, file_list} -> {:ok, Enum.map(file_list, &IO.chardata_to_string/1)}
       {:error, _} = error -> error
     end
@@ -1314,11 +1175,11 @@ defmodule File do
 
   Note that if the option `:delayed_write` was used when opening the file,
   `close/1` might return an old write error and not even try to close the file.
-  See `open/2` for more information.
+  See `open/2`.
   """
   @spec close(io_device) :: :ok | {:error, posix | :badarg | :terminated}
   def close(io_device) do
-    :file.close(io_device)
+    F.close(io_device)
   end
 
   @doc """
@@ -1327,7 +1188,7 @@ defmodule File do
   The stream implements both `Enumerable` and `Collectable` protocols,
   which means it can be used both for read and write.
 
-  The `line_or_bytes` argument configures how the file is read when
+  The `line_or_byte` argument configures how the file is read when
   streaming, by `:line` (default) or by a given number of bytes.
 
   Operating the stream can fail on open for the same reasons as
@@ -1342,30 +1203,25 @@ defmodule File do
   in raw mode for performance reasons. Therefore, Elixir **will** open
   streams in `:raw` mode with the `:read_ahead` option unless an encoding
   is specified. This means any data streamed into the file must be
-  converted to `t:iodata/0` type. If you pass `[:utf8]` in the modes parameter,
+  converted to `iodata` type. If you pass `[:utf8]` in the modes parameter,
   the underlying stream will use `IO.write/2` and the `String.Chars` protocol
   to convert the data. See `IO.binwrite/2` and `IO.write/2` .
 
   One may also consider passing the `:delayed_write` option if the stream
   is meant to be written to under a tight loop.
 
-  ## Byte order marks
-
-  If you pass `:trim_bom` in the modes parameter, the stream will
-  trim UTF-8, UTF-16 and UTF-32 byte order marks when reading from file.
-
   ## Examples
 
       # Read in 2048 byte chunks rather than lines
       File.stream!("./test/test.data", [], 2048)
-      #=> %File.Stream{line_or_bytes: 2048, modes: [:raw, :read_ahead, :binary],
+      #=>  %File.Stream{line_or_bytes: 2048, modes: [:raw, :read_ahead, :binary],
       #=> path: "./test/test.data", raw: true}
 
   See `Stream.run/1` for an example of streaming into a file.
 
   """
   def stream!(path, modes \\ [], line_or_bytes \\ :line) do
-    modes = normalize_modes(modes, true)
+    modes = open_defaults(modes, true)
     File.Stream.__build__(IO.chardata_to_string(path), modes, line_or_bytes)
   end
 
@@ -1376,28 +1232,26 @@ defmodule File do
 
   ## Permissions
 
-  File permissions are specified by adding together the following octal flags:
+    * 0o400 - read permission: owner
+    * 0o200 - write permission: owner
+    * 0o100 - execute permission: owner
 
-    * `0o400` - read permission: owner
-    * `0o200` - write permission: owner
-    * `0o100` - execute permission: owner
+    * 0o040 - read permission: group
+    * 0o020 - write permission: group
+    * 0o010 - execute permission: group
 
-    * `0o040` - read permission: group
-    * `0o020` - write permission: group
-    * `0o010` - execute permission: group
+    * 0o004 - read permission: other
+    * 0o002 - write permission: other
+    * 0o001 - execute permission: other
 
-    * `0o004` - read permission: other
-    * `0o002` - write permission: other
-    * `0o001` - execute permission: other
-
-  For example, setting the mode `0o755` gives it
+  For example, setting the mode 0o755 gives it
   write, read and execute permission to the owner
   and both read and execute permission to group
   and others.
   """
   @spec chmod(Path.t, non_neg_integer) :: :ok | {:error, posix}
   def chmod(path, mode) do
-    :file.change_mode(IO.chardata_to_string(path), mode)
+    F.change_mode(IO.chardata_to_string(path), mode)
   end
 
   @doc """
@@ -1420,7 +1274,7 @@ defmodule File do
   """
   @spec chgrp(Path.t, non_neg_integer) :: :ok | {:error, posix}
   def chgrp(path, gid) do
-    :file.change_group(IO.chardata_to_string(path), gid)
+    F.change_group(IO.chardata_to_string(path), gid)
   end
 
   @doc """
@@ -1443,7 +1297,7 @@ defmodule File do
   """
   @spec chown(Path.t, non_neg_integer) :: :ok | {:error, posix}
   def chown(path, uid) do
-    :file.change_owner(IO.chardata_to_string(path), uid)
+    F.change_owner(IO.chardata_to_string(path), uid)
   end
 
   @doc """
@@ -1461,40 +1315,24 @@ defmodule File do
 
   ## Helpers
 
-  @read_ahead_size 64 * 1024
+  @read_ahead 64*1024
 
-  defp assert_no_null_byte!(binary, operation) do
-    case :binary.match(binary, "\0") do
-      {_, _} ->
-        raise ArgumentError, "cannot execute #{operation} for path with null byte, got: #{inspect binary}"
-      :nomatch ->
-        binary
-    end
+  defp open_defaults([:char_list|t], _add_binary) do
+    open_defaults(t, false)
   end
 
-  defp normalize_modes([:utf8 | rest], binary?) do
-    [encoding: :utf8] ++ normalize_modes(rest, binary?)
+  defp open_defaults([:utf8|t], add_binary) do
+    open_defaults([{:encoding, :utf8}|t], add_binary)
   end
-  defp normalize_modes([:read_ahead | rest], binary?) do
-    [read_ahead: @read_ahead_size] ++ normalize_modes(rest, binary?)
-  end
-  # TODO: Remove :char_list mode by 2.0
-  defp normalize_modes([mode | rest], _binary?) when mode in [:charlist, :char_list] do
-    if mode == :char_list do
-      IO.warn "the :char_list mode is deprecated, use :charlist"
-    end
-    normalize_modes(rest, false)
-  end
-  defp normalize_modes([mode | rest], binary?) do
-    [mode | normalize_modes(rest, binary?)]
-  end
-  defp normalize_modes([], true), do: [:binary]
-  defp normalize_modes([], false), do: []
 
-  defp maybe_to_string(path) when is_list(path),
-    do: IO.chardata_to_string(path)
-  defp maybe_to_string(path) when is_binary(path),
-    do: path
-  defp maybe_to_string(path),
-    do: path
+  defp open_defaults([:read_ahead|t], add_binary) do
+    open_defaults([{:read_ahead, @read_ahead}|t], add_binary)
+  end
+
+  defp open_defaults([h|t], add_binary) do
+    [h|open_defaults(t, add_binary)]
+  end
+
+  defp open_defaults([], true),  do: [:binary]
+  defp open_defaults([], false), do: []
 end

lib/elixir/lib/file/stat.ex

@@ -32,7 +32,7 @@ defmodule File.Stat do
       systems which have no concept of links.
 
     * `major_device` - identifies the file system where the file is located.
-      In Windows, the number indicates a drive as follows: 0 means A:, 1 means
+      In windows, the number indicates a drive as follows: 0 means A:, 1 means
       B:, and so on.
 
     * `minor_device` - only valid for character devices on Unix. In all other

lib/elixir/lib/file/stream.ex

@@ -36,9 +36,9 @@ 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
+      case :file.open(path, [:write|modes]) do
         {:ok, device} ->
           {:ok, into(device, stream, raw)}
         {:error, reason} ->
@@ -67,14 +67,13 @@ 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
+      modes = for mode <- modes, not mode in [:write, :append], do: mode
+
       start_fun =
         fn ->
-          case :file.open(path, read_modes(modes)) do
-            {:ok, device} ->
-              if :trim_bom in modes, do: trim_bom(device), else: device
+          case :file.open(path, modes) do
+            {:ok, device}    -> device
             {:error, reason} ->
               raise File.Error, reason: reason, action: "stream", path: path
           end
@@ -89,70 +88,12 @@ defmodule File.Stream do
       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}) do
-      case File.stat(path) do
-        {:ok, %{size: 0}} ->
-          {:error, __MODULE__}
-        {:ok, %{size: size}} ->
-          {:ok, div(size, bytes) + if(rem(size, bytes) == 0, do: 0, else: 1)}
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
+    def count(_stream) do
+      {:error, __MODULE__}
     end
 
     def member?(_stream, _term) do
       {:error, __MODULE__}
     end
-
-    defp trim_bom(device) do
-      header = IO.binread(device, 4)
-      {:ok, _new_pos} = :file.position(device, bom_length(header))
-      device
-    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,34 +2,30 @@ import Kernel, except: [round: 1]
 
 defmodule Float do
   @moduledoc """
-  Functions for working with floating-point numbers.
+  Functions for working with floating point numbers.
   """
 
-  import Bitwise
-
-  @power_of_2_to_52 4503599627370496
-  @precision_range 0..15
-  @type precision_range :: 0..15
-
   @doc """
   Parses a binary into a float.
 
-  If successful, returns a tuple in the form of `{float, remainder_of_binary}`;
+  If successful, returns a tuple of the form `{float, remainder_of_binary}`;
   when the binary cannot be coerced into a valid float, the atom `:error` is
   returned.
 
   If the size of float exceeds the maximum size of `1.7976931348623157e+308`,
   the `ArgumentError` exception is raised.
 
-  If you want to convert a string-formatted float directly to a float,
+  If a float formatted string wants to be directly converted to a float,
   `String.to_float/1` can be used instead.
 
   ## Examples
 
       iex> Float.parse("34")
       {34.0, ""}
+
       iex> Float.parse("34.25")
       {34.25, ""}
+
       iex> Float.parse("56.5xyz")
       {56.5, "xyz"}
 
@@ -80,20 +76,8 @@ defmodule Float do
   @doc """
   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.
-
-  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.
 
   This function always returns a float. `Kernel.trunc/1` may be used instead to
   truncate the result to an integer afterwards.
@@ -102,42 +86,29 @@ defmodule Float do
 
       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.
 
@@ -145,304 +116,136 @@ 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.
-
-  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)
-      -6.0
-      iex> Float.round(12.341444444444441, 15)
-      12.341444444444441
+
+      iex> Float.round(-5.5675, 3)
+      -5.568
 
   """
-  @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
-      count <= 0 or  # There is no decimal precision
-      (0 == exp and <<0::52>> == significant) -> #zero or minus zero
-        float
-
-      count >= 104 -> # Precision beyond 15 digits
-        case rounding do
-          :ceil when sign === 0 -> 1 / power_of_10(precision)
-          :floor when sign === 1 -> -1 / power_of_10(precision)
-          _ -> 0.0
-        end
-
-      count <= precision -> # We are asking more precision than we have
-        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.
+  Returns a char list which corresponds to the text representation of the given float.
+
+  Inlined by the compiler.
 
   ## 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}
+      iex> Float.to_char_list(7.0)
+      '7.00000000000000000000e+00'
 
   """
-  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
+  @spec to_char_list(float) :: char_list
+  def to_char_list(float) do
+    :erlang.float_to_list(float)
   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
+  Returns a list which corresponds to the text representation
   of the given float.
 
-  It uses the shortest representation according to algorithm described
-  in "Printing Floating-Point Numbers Quickly and Accurately" in
-  Proceedings of the SIGPLAN '96 Conference on Programming Language
-  Design and Implementation.
+  ## Options
+
+    * `:decimals`   - number of decimal points to show
+    * `:scientific` - number of decimal points to show, in scientific format
+    * `:compact`    - when `true`, use the most compact representation (ignored
+      with the `scientific` option)
 
   ## Examples
 
-      iex> Float.to_charlist(7.0)
-      '7.0'
+      iex> Float.to_char_list 7.1, [decimals: 2, compact: true]
+      '7.1'
 
   """
-  @spec to_charlist(float) :: charlist
-  def to_charlist(float) when is_float(float) do
-    :io_lib_format.fwrite_g(float)
+  @spec to_char_list(float, list) :: char_list
+  def to_char_list(float, options) do
+    :erlang.float_to_list(float, expand_compact(options))
   end
 
   @doc """
   Returns a binary which corresponds to the text representation
   of the given float.
 
-  It uses the shortest representation according to algorithm described
-  in "Printing Floating-Point Numbers Quickly and Accurately" in
-  Proceedings of the SIGPLAN '96 Conference on Programming Language
-  Design and Implementation.
+  Inlined by the compiler.
 
   ## Examples
 
       iex> Float.to_string(7.0)
-      "7.0"
+      "7.00000000000000000000e+00"
 
   """
   @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))
+  def to_string(float) do
+    :erlang.float_to_binary(float)
   end
 
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  def to_char_list(float), do: Float.to_charlist(float)
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `float`.
 
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def to_char_list(float, options) do
-    :erlang.float_to_list(float, expand_compact(options))
-  end
+  ## Options
 
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
+    * `:decimals`   - number of decimal points to show
+    * `:scientific` - number of decimal points to show, in scientific format
+    * `:compact`    - when `true`, use the most compact representation (ignored
+      with the `scientific` option)
+
+  ## Examples
+
+      iex> Float.to_string 7.1, [decimals: 2, compact: true]
+      "7.1"
+
+  """
+  @spec to_string(float, list) :: String.t
   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, 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: []
 end

lib/elixir/lib/gen_event.ex

@@ -1,90 +1,304 @@
 defmodule GenEvent do
-  # TODO: Remove by 2.0
-
-  # Functions from this module are deprecated in elixir_dispatch.
-
   @moduledoc """
-  WARNING: this module is deprecated.
+  A behaviour module for implementing event handling functionality.
 
-  If you are interested in implementing an event manager, please read the
-  "Alternatives" section below. If you have to implement an event handler to
-  integrate with an existing system, such as Elixir's Logger, please use
-  `:gen_event` instead.
+  The event handling model consists of a generic event manager
+  process with an arbitrary number of event handlers which are
+  added and deleted dynamically.
 
-  ## Alternatives
+  An event manager implemented using this module will have a standard
+  set of interface functions and include functionality for tracing and
+  error reporting. It will also fit into a supervision tree.
 
-  There are a few suitable alternatives to replace GenEvent. Each of them can be
-  the most beneficial based on the use case.
+  ## Example
 
-  ### Supervisor and GenServers
+  There are many use cases for event handlers. For example, a logging
+  system can be built using event handlers where each log message is
+  an event and different event handlers can be plugged to handle the
+  log messages. One handler may print error messages on the terminal,
+  another can write it to a file, while a third one can keep the
+  messages in memory (like a buffer) until they are read.
 
-  One alternative to GenEvent is a very minimal solution consisting of using a
-  supervisor and multiple GenServers started under it. The supervisor acts as
-  the "event manager" and the children GenServers act as the "event handlers".
-  This approach has some shortcomings (it provides no backpressure for example)
-  but can still replace GenEvent for low-profile usages of it. [This blog post
-  by José
-  Valim](http://blog.plataformatec.com.br/2016/11/replacing-genevent-by-a-supervisor-genserver/)
-  has more detailed information on this approach.
+  As an example, let's have a GenEvent that accumulates messages until
+  they are collected by an explicit call.
 
-  ### GenStage
+      # Define a Event Handler
+      defmodule LoggerHandler do
+        use GenEvent
 
-  If the use case where you were using GenEvent requires more complex logic,
-  [GenStage](https://github.com/elixir-lang/gen_stage) provides a great
-  alternative. GenStage is an external Elixir library maintained by the Elixir
-  team; it provides tool to implement systems that exchange events in a
-  demand-driven way with built-in support for backpressure. See the [GenStage
-  documentation](https://hexdocs.pm/gen_stage) for more information.
+        # Callbacks
 
-  ### `:gen_event`
+        def handle_event({:log, x}, messages) do
+          {:ok, [x|messages]}
+        end
 
-  If your use case requires exactly what GenEvent provided, or you have to
-  integrate with an existing `:gen_event`-based system, you can still use the
-  [`:gen_event`](http://erlang.org/doc/man/gen_event.html) Erlang module.
+        def handle_call(:messages, messages) do
+          {:ok, Enum.reverse(messages), []}
+        end
+      end
+
+      # Start a new event manager.
+      {:ok, pid} = GenEvent.start_link([])
+
+      # Attach an event handler to the event manager.
+      GenEvent.add_handler(pid, LoggerHandler, [])
+      #=> :ok
+
+      # Send some events to the event manager.
+      GenEvent.notify(pid, {:log, 1})
+      #=> :ok
+
+      GenEvent.notify(pid, {:log, 2})
+      #=> :ok
+
+      # Call functions on specific handlers in the manager.
+      GenEvent.call(pid, LoggerHandler, :messages)
+      #=> [1, 2]
+
+      GenEvent.call(pid, LoggerHandler, :messages)
+      #=> []
+
+  We start a new event manager by calling `GenEvent.start_link/1`.
+  Notifications can be sent to the event manager which will then
+  invoke `handle_event/2` for each registered handler.
+
+  We can add new handlers with `add_handler/3` and `add_mon_handler/3`.
+  Calls can also be made to specific handlers by using `call/3`.
+
+  ## Callbacks
+
+  There are 6 callbacks required to be implemented in a `GenEvent`. By
+  adding `use GenEvent` to your module, Elixir will automatically define
+  all 6 callbacks for you, leaving it up to you to implement the ones
+  you want to customize.
+
+  ## Name Registration
+
+  A GenEvent is bound to the same name registration rules as a `GenServer`.
+  Read more about it in the `GenServer` docs.
+
+  ## Modes
+
+  GenEvent stream supports three different notifications.
+
+  On `GenEvent.ack_notify/2`, the manager acknowledges each event,
+  providing backpressure, but processing of the message happens
+  asynchronously.
+
+  On `GenEvent.sync_notify/2`, the manager acknowledges an event
+  just after it is processed by all event handlers.
+
+  On `GenEvent.notify/2`, all events are processed asynchronously and
+  there is no ack (which means there is no backpressure).
+
+  ## Streaming
+
+  `GenEvent` messages can be streamed with the help of `stream/2`.
+  You will need to start another process to consume the stream:
+
+      Task.start_link fn ->
+        stream = GenEvent.stream(pid)
+
+        # Discard the next 3 events
+        _ = Enum.drop(stream, 3)
+
+        # Print all remaining events
+        for event <- stream do
+          IO.inspect event
+        end
+      end
+
+  Now call `GenEvent.notify/2` multiple times. You will see the
+  first three events will be skipped while the rest will be
+  continuously printed.
+
+  ## Learn more and compatibility
+
+  If you wish to find out more about gen events, Elixir getting started
+  guides provide a tutorial-like introduction. The documentation and links
+  in Erlang can also provide extra insight.
+
+    * [Introduction to Mix – Elixir's Getting Started Guide](http://elixir-lang.org/getting-started/mix-otp/introduction-to-mix.html)
+    * [`:gen_event` module documentation](http://www.erlang.org/doc/man/gen_event.html)
+    * [Event Handlers – Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/event-handlers)
+
+  Keep in mind though Elixir and Erlang gen events are not 100% compatible.
+  The `:gen_event.add_sup_handler/3` is not supported by Elixir's GenEvent,
+  which in turn supports `GenEvent.add_mon_handler/3`.
+
+  The benefits of the monitoring approach are described in the "Don't drink
+  too much kool aid" section of the "Learn you some Erlang" link above. Due
+  to those changes, Elixir's GenEvent does not trap exits by default.
+
+  Furthermore, Elixir also normalizes the `{:error, _}` tuples returned
+  by many functions, in order to be more consistent with themselves and
+  the `GenServer` module.
   """
 
+  @doc """
+  Invoked when the handler is added to the `GenEvent` process. `add_handler/3`,
+  (and `add_mon_handler/3`) will block until it returns.
+
+  `args` is the argument term (third argument) passed to `add_handler/3`.
+
+  Returning `{:ok, state}` will cause `add_handler/3` to return `:ok` and the
+  handler to become part of the `GenEvent` loop with state `state`.
+
+  Returning `{:ok, state, :hibernate}` is similar to
+  `{:ok, state}` except the `GenEvent` process is hibernated before continuing
+  its loop. See `handle_event/2` for more information on hibernation.
+
+  Returning `{:error, reason}` will cause `add_handler/3` to return
+  `{:error, reason}` and the handler is not added to `GenEvent` loop.
+  """
   @callback init(args :: term) ::
     {:ok, state} |
     {:ok, state, :hibernate} |
     {:error, reason :: any} when state: any
 
+  @doc """
+  Invoked to handle `notify/2`, `ack_notify/2` or `sync_notify/2` messages.
+
+  `event` is the event message and `state` is the current state of the handler.
+
+  Returning `{:ok, new_state}` sets the handler's state to `new_state` and the
+  `GenEvent` loop continues.
+
+  Returning `{:ok, new_state, :hibernate}` is similar to
+  `{:ok, new_state}` except the process is hibernated once all handlers have
+  handled the events. The `GenEvent` process will continue the loop once a
+  message is its message queue. If a message is already in the message queue
+  this will be immediately. Hibernating a `GenEvent` causes garbage collection
+  and leaves a continuous heap that minimises the memory used by the process.
+
+  Hibernating should not be used aggressively as too much time could be spent
+  garbage collecting. Normally it should only be used when a message is not
+  expected soon and minimising the memory of the process is shown to be
+  beneficial.
+
+  Returning `:remove_handler` removes the handler from the `GenEvent` loop and
+  calls `terminate/2` with reason `:remove_handler` and state `state`.
+  """
   @callback handle_event(event :: term, state :: term) ::
     {:ok, new_state} |
     {:ok, new_state, :hibernate} |
     :remove_handler when new_state: term
 
+  @doc """
+  Invoked to handle synchronous `call/4` messages to a specific handler.
+
+  `request` is the request message sent by a `call/4` and `state` is the current
+  state of the handler.
+
+  Returning `{:ok, reply, new_state}` sends `reply` as a response to the call
+  and sets the handler's state to `new_state`.
+
+  Returning `{:ok, reply, new_state, :hibernate}` is similar to
+  `{:ok, reply, new_state}` except the process is hibernated. See
+  `handle_event/2` for more information on hibernation.
+
+  Returning `{:remove_handler, reply}` sends `reply` as a reponse to the call,
+  removes the handler from the `GenEvent` loop and calls `terminate/2` with
+  reason `:remove_handler` and state `state`.
+  """
+
   @callback handle_call(request :: term, state :: term) ::
     {:ok, reply, new_state} |
     {:ok, reply, new_state, :hibernate} |
     {:remove_handler, reply} when reply: term, new_state: term
 
+  @doc """
+  Invoked to handle all other messages. All handlers are run in the `GenEvent`
+  process so messages intended for other handlers should be ignored with a catch
+  all clause.
+
+  `msg` is the message and `state` is the current state of the handler.
+
+  Return values are the same as `handle_event/2`.
+  """
   @callback handle_info(msg :: term, state :: term) ::
     {:ok, new_state} |
     {:ok, new_state, :hibernate} |
     :remove_handler when new_state: term
 
+  @doc """
+  Invoked when the server is about to exit. It should do any cleanup required.
+
+  `reason` is removal reason and `state` is the current state of the handler.
+  The return value is returned to `GenEvent.remove_handler/3` or ignored if
+  removing for another reason.
+
+  `reason` is one of:
+
+  -  `:stop` - manager is terminating
+  -  `{:stop, term}` - monitored process terminated (for monitored handlers)
+  -  `:remove_handler` - handler is being removed
+  -  `{:error, term}` - handler crashed or returned a bad value and an error is
+  logged
+  -  `term` - any term passed to functions like `GenEvent.remove_handler/3`
+
+  If part of a supervision tree, a `GenEvent`'s `Supervisor` will send an exit
+  signal when shutting it down. The exit signal is based on the shutdown
+  strategy in the child's specification. If it is `:brutal_kill` the `GenEvent`
+  is killed and so `terminate/2` is not called for its handlers. However if it is
+  a timeout the `Supervisor` will send the exit signal `:shutdown` and the
+  `GenEvent` will have the duration of the timeout to call `terminate/2` on all
+  of its handlers - if the process is still alive after the timeout it is
+  killed.
+
+  If the `GenEvent` receives an exit signal (that is not `:normal`) from any
+  process when it is not trapping exits it will exit abruptly with the same
+  reason and so not call the handlers' `terminate/2`. Note that a process does
+  *NOT* trap exits by default and an exit signal is sent when a linked process
+  exits or its node is disconnected. Therefore it is not guaranteed that
+  `terminate/2` is called when a `GenEvent` exits.
+
+  Care should be taken to cleanup because the `GenEvent` can continue is loop
+  after removing the handler. This is different to most other OTP behaviours.
+  For example if the handler controls a `port` (e.g. `:gen_tcp.socket`) or
+  `File.io_device`, it will be need to be closed in `terminate/2` as the
+  process is not exiting so will not be automatically cleaned up.
+  """
   @callback terminate(reason, state :: term) ::
     term when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
 
+  @doc """
+  Invoked to change the state of the handler when a different version of the
+  handler's module module is loaded (hot code swapping) and the state's term
+  structure should be changed.
+
+  `old_vsn` is the previous version of the module (defined by the `@vsn`
+  attribute) when upgrading. When downgrading the previous version is wrapped in
+  a 2-tuple with first element `:down`. `state` is the current state of the
+  handker and `extra` is any extra data required to change the state.
+
+  Returning `{:ok, new_state}` changes the state to `new_state` and the code
+  change is successful.
+
+  If `code_change/3` raises, the code change fails and the handler will continue
+  with its previous state. Therefore this callback does not usually contain side
+  effects.
+  """
   @callback code_change(old_vsn, state :: term, extra :: term) ::
     {:ok, new_state :: term} when old_vsn: term | {:down, term}
 
+  @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}
 
+  @typedoc "The GenEvent manager name"
   @type name :: atom | {:global, term} | {:via, module, term}
 
+  @typedoc "Options used by the `start*` functions"
   @type options :: [name: name]
 
+  @typedoc "The event manager reference"
   @type manager :: pid | name | {atom, node}
 
+  @typedoc "Supported values for new handlers"
   @type handler :: atom | {atom, term}
 
   @doc false
   defmacro __using__(_) do
-    %{file: file, line: line} = __CALLER__
-    deprecation_message = "the GenEvent module is deprecated, see its documentation for alternatives"
-    :elixir_errors.warn(line, file, deprecation_message)
-
     quote location: :keep do
       @behaviour :gen_event
 
@@ -100,16 +314,11 @@ defmodule GenEvent do
 
       @doc false
       def handle_call(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
-        # We do this to trick Dialyzer to not complain about non-local returns.
+        # We do this to trick dialyzer to not complain about non-local returns.
+        reason = {:bad_call, msg}
         case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to call GenEvent #{inspect proc} but no handle_call/2 clause was provided"
-          1 -> {:remove_handler, {:bad_call, msg}}
+          0 -> exit(reason)
+          1 -> {:remove_handler, reason}
         end
       end
 
@@ -133,13 +342,33 @@ defmodule GenEvent do
     end
   end
 
-  @doc false
+  @doc """
+  Starts an event manager linked to the current process.
+
+  This is often used to start the `GenEvent` as part of a supervision tree.
+
+  It accepts the `:name` option which is described under the `Name Registration`
+  section in the `GenServer` module docs.
+
+  If the event manager is successfully created and initialized, the function
+  returns `{:ok, pid}`, where pid is the pid of the server. If a process with
+  the specified server name already exists, the function returns
+  `{:error, {:already_started, pid}}` with the pid of that process.
+
+  Note that a `GenEvent` started with `start_link/1` is linked to the
+  parent process and will exit not only on crashes but also if the parent
+  process exits with `:normal` reason.
+  """
   @spec start_link(options) :: on_start
   def start_link(options \\ []) when is_list(options) do
     do_start(:link, options)
   end
 
-  @doc false
+  @doc """
+  Starts an event manager process without links (outside of a supervision tree).
+
+  See `start_link/1` for more information.
+  """
   @spec start(options) :: on_start
   def start(options \\ []) when is_list(options) do
     do_start(:nolink, options)
@@ -153,45 +382,111 @@ defmodule GenEvent do
         :gen.start(GenEvent, mode, @no_callback, [], [])
       atom when is_atom(atom) ->
         :gen.start(GenEvent, mode, {:local, atom}, @no_callback, [], [])
-      {:global, _term} = tuple ->
-        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-      {:via, via_module, _term} = tuple when is_atom(via_module) ->
-        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-      other ->
-        raise ArgumentError, """
-        expected :name option to be one of:
-
-          * nil
-          * atom
-          * {:global, term}
-          * {:via, module, term}
-
-        Got: #{inspect(other)}
-        """
+      other when is_tuple(other) ->
+        :gen.start(GenEvent, mode, other, @no_callback, [], [])
     end
   end
 
-  @doc false
-  @spec stream(manager, keyword) :: GenEvent.Stream.t
+  @doc """
+  Returns a stream that consumes events from the `manager`.
+
+  The stream is a `GenEvent` struct that implements the `Enumerable`
+  protocol. Consumption of events only begins when enumeration starts.
+
+  Note streaming is specific to Elixir's GenEvent and does not work
+  with Erlang ones.
+
+  ## Options
+
+    * `:timeout` - raises if no event arrives in X milliseconds
+      (defaults to `:infinity`)
+
+  """
+  @spec stream(manager, Keyword.t) :: GenEvent.Stream.t
   def stream(manager, options \\ []) do
     %GenEvent.Stream{
       manager: manager,
       timeout: Keyword.get(options, :timeout, :infinity)}
   end
 
-  @doc false
+  @doc """
+  Adds a new event handler to the event `manager`.
+
+  The event manager will call the `init/1` callback with `args` to
+  initiate the event handler and its internal state.
+
+  If `init/1` returns a correct value indicating successful completion,
+  the event manager adds the event handler and this function returns
+  `:ok`. If the callback fails with `reason` or returns `{:error, reason}`,
+  the event handler is ignored and this function returns `{:error, reason}`.
+
+  If the given handler was previously installed at the manager, this
+  function returns `{:error, :already_present}`.
+
+  For installing multiple instances of the same handler, `{Module, id}` instead
+  of `Module` must be used. The handler could be then referenced with 
+  `{Module, id}` instead of just `Module`.
+  """
   @spec add_handler(manager, handler, term) :: :ok | {:error, term}
   def add_handler(manager, handler, args) do
     rpc(manager, {:add_handler, handler, args})
   end
 
-  @doc false
+  @doc """
+  Adds a monitored event handler to the event `manager`.
+
+  Expects the same input and returns the same values as `add_handler/3`.
+
+  ## Monitored handlers
+
+  A monitored handler implies the calling process will now be monitored
+  by the GenEvent manager.
+
+  If the calling process later terminates with `reason`, the event manager
+  will delete the event handler by calling the `terminate/2` callback with
+  `{:stop, reason}` as argument. If the event handler later is deleted,
+  the event manager sends a message `{:gen_event_EXIT, handler, reason}`
+  to the calling process. Reason is one of the following:
+
+    * `:normal` - if the event handler has been removed due to a call to
+      `remove_handler/3`, or `:remove_handler` has been returned by a callback
+      function
+
+    * `:shutdown` - if the event handler has been removed because the event
+      manager is terminating
+
+    * `{:swapped, new_handler, pid}` - if the process pid has replaced the
+      event handler by another
+
+    * a term - if the event handler is removed due to an error. Which term
+      depends on the error
+
+  Keep in mind that the `{:gen_event_EXIT, handler, reason}` message is not
+  guaranteed to be delivered in case the manager crashes. If you want to
+  guarantee the message is delivered, you have two options:
+
+    * monitor the event manager
+    * link to the event manager and then set `Process.flag(:trap_exit, true)`
+      in your handler callback
+
+  Finally, this functionality only works with GenEvent started via this
+  module (it is not backwards compatible with Erlang's `:gen_event`).
+  """
   @spec add_mon_handler(manager, handler, term) :: :ok | {:error, term}
   def add_mon_handler(manager, handler, args) do
     rpc(manager, {:add_mon_handler, handler, args, self()})
   end
 
-  @doc false
+  @doc """
+  Sends an event notification to the event `manager`.
+
+  The event manager will call `handle_event/2` for each
+  installed event handler.
+
+  `notify` is asynchronous and will return immediately after the
+  notification is sent. `notify` will not fail even if the specified
+  event manager does not exist, unless it is specified as an atom.
+  """
   @spec notify(manager, term) :: :ok
   def notify(manager, event)
 
@@ -204,7 +499,7 @@ defmodule GenEvent do
     end
   end
 
-  def notify({:via, mod, name}, msg) when is_atom(mod) do
+  def notify({:via, mod, name}, msg) do
     try do
       mod.send(name, {:notify, msg})
       :ok
@@ -213,28 +508,50 @@ defmodule GenEvent do
     end
   end
 
-  def notify(manager, msg)
-      when is_pid(manager)
-      when is_atom(manager)
-      when tuple_size(manager) == 2 and
-        is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do
-    send(manager, {:notify, msg})
+  def notify(other, msg) do
+    send(other, {:notify, msg})
     :ok
   end
 
-  @doc false
+  @doc """
+  Sends a sync event notification to the event `manager`.
+
+  In other words, this function only returns `:ok` after the event manager
+  invokes the `handle_event/2` callback on each installed event handler.
+
+  See `notify/2` for more info.
+  """
   @spec sync_notify(manager, term) :: :ok
   def sync_notify(manager, event) do
     rpc(manager, {:sync_notify, event})
   end
 
-  @doc false
+  @doc """
+  Sends a ack event notification to the event `manager`.
+
+  In other words, this function only returns `:ok` as soon as the
+  event manager starts processing this event, but it does not wait
+  for event handlers to process the sent event.
+
+  See `notify/2` for more info. Note this function is specific
+  to Elixir's GenEvent and does not work with Erlang ones.
+  """
   @spec ack_notify(manager, term) :: :ok
   def ack_notify(manager, event) do
     rpc(manager, {:ack_notify, event})
   end
 
-  @doc false
+  @doc """
+  Makes a synchronous call to the event `handler` installed in `manager`.
+
+  The given `request` is sent and the caller waits until a reply arrives or
+  a timeout occurs. The event manager will call `handle_call/2` to handle
+  the request.
+
+  The return value `reply` is defined in the return value of `handle_call/2`.
+  If the specified event handler is not installed, the function returns
+  `{:error, :not_found}`.
+  """
   @spec call(manager, handler, term, timeout) ::  term | {:error, term}
   def call(manager, handler, request, timeout \\ 5000) do
     try do
@@ -247,31 +564,70 @@ defmodule GenEvent do
     end
   end
 
-  @doc false
+  @doc """
+  Removes an event handler from the event `manager`.
+
+  The event manager will call `terminate/2` to terminate the event handler
+  and return the callback value. If the specified event handler is not
+  installed, the function returns `{:error, :not_found}`.
+  """
   @spec remove_handler(manager, handler, term) :: term | {:error, term}
   def remove_handler(manager, handler, args) do
     rpc(manager, {:delete_handler, handler, args})
   end
 
-  @doc false
+  @doc """
+  Replaces an old event handler with a new one in the event `manager`.
+
+  First, the old event handler is deleted by calling `terminate/2` with
+  the given `args1` and collects the return value. Then the new event handler
+  is added and initiated by calling `init({args2, term})`, where `term` is the
+  return value of calling `terminate/2` in the old handler. This makes it
+  possible to transfer information from one handler to another.
+
+  The new handler will be added even if the specified old event handler
+  is not installed or if the handler fails to terminate with a given reason
+  in which case `state = {:error, term}`.
+
+  If `init/1` in the second handler returns a correct value, this
+  function returns `:ok`.
+  """
   @spec swap_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
   def swap_handler(manager, handler1, args1, handler2, args2) do
     rpc(manager, {:swap_handler, handler1, args1, handler2, args2})
   end
 
-  @doc false
+  @doc """
+  Replaces an old event handler with a new monitored one in the event `manager`.
+
+  Read the docs for `add_mon_handler/3` and `swap_handler/5` for more information.
+  """
   @spec swap_mon_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
   def swap_mon_handler(manager, handler1, args1, handler2, args2) do
     rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})
   end
 
-  @doc false
+  @doc """
+  Returns a list of all event handlers installed in the `manager`.
+  """
   @spec which_handlers(manager) :: [handler]
   def which_handlers(manager) do
     rpc(manager, :which_handlers)
   end
 
-  @doc false
+  @doc """
+  Stops the manager with the given `reason`.
+
+  Before terminating, the event manager will call
+  `terminate(:stop, ...)` for each installed event handler.
+  It returns `:ok` if the manager 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.
+  """
   @spec stop(manager, reason :: term, timeout) :: :ok
   def stop(manager, reason \\ :normal, timeout \\ :infinity) do
     :gen.stop(manager, reason, timeout)
@@ -292,7 +648,7 @@ defmodule GenEvent do
     init_it(starter, self(), name, mod, args, options)
   end
 
-  def init_it(starter, parent, name, _mod, _args, options) do
+  def init_it(starter, parent, name, _, _, options) do
     Process.put(:"$initial_call", {__MODULE__, :init_it, 6})
     debug =
       if function_exported?(:gen, :debug_options, 2) do
@@ -550,13 +906,13 @@ defmodule GenEvent do
     {hib, server_collect_process_handlers(mode, event, streams, handlers, name)}
   end
 
-  defp server_split_process_handlers(mode, event, [handler | t], handlers, streams) do
+  defp server_split_process_handlers(mode, event, [handler|t], handlers, streams) do
     case handler(handler, :id) do
       {pid, _ref} when is_pid(pid) ->
         server_process_notify(mode, event, handler)
-        server_split_process_handlers(mode, event, t, handlers, [handler | streams])
+        server_split_process_handlers(mode, event, t, handlers, [handler|streams])
       _ ->
-        server_split_process_handlers(mode, event, t, [handler | handlers], streams)
+        server_split_process_handlers(mode, event, t, [handler|handlers], streams)
     end
   end
 
@@ -572,10 +928,10 @@ defmodule GenEvent do
   defp mode_to_tag(:sync),  do: :sync_notify
   defp mode_to_tag(:async), do: :notify
 
-  defp server_notify(event, fun, [handler | t], name, handlers, acc, hib) do
+  defp server_notify(event, fun, [handler|t], name, handlers, acc, hib) do
     case server_update(handler, fun, event, name, handlers) do
       {new_hib, handler} ->
-        server_notify(event, fun, t, name, handlers, [handler | acc], hib or new_hib)
+        server_notify(event, fun, t, name, handlers, [handler|acc], hib or new_hib)
       :error ->
         server_notify(event, fun, t, name, handlers, acc, hib)
     end
@@ -609,16 +965,16 @@ defmodule GenEvent do
     end
   end
 
-  defp server_collect_process_handlers(:async, event, [handler | t], handlers, name) do
-    server_collect_process_handlers(:async, event, t, [handler | handlers], name)
+  defp server_collect_process_handlers(:async, event, [handler|t], handlers, name) do
+    server_collect_process_handlers(:async, event, t, [handler|handlers], name)
   end
 
-  defp server_collect_process_handlers(mode, event, [handler | t], handlers, name) when mode in [:sync, :ack] do
+  defp server_collect_process_handlers(mode, event, [handler|t], handlers, name) when mode in [:sync, :ack] do
     handler(ref: ref, id: id) = handler
 
     receive do
       {^ref, :ok} ->
-        server_collect_process_handlers(mode, event, t, [handler | handlers], name)
+        server_collect_process_handlers(mode, event, t, [handler|handlers], name)
       {_from, tag, {:delete_handler, ^id, args}} ->
         do_terminate(handler, args, :remove, name, :normal)
         reply(tag, :ok)
@@ -708,9 +1064,9 @@ defmodule GenEvent do
           {:ok, res} ->
             case res do
               {:ok, state} ->
-                {false, succ, [handler(handler, state: state) | handlers]}
+                {false, succ, [handler(handler, state: state)|handlers]}
               {:ok, state, :hibernate} ->
-                {true, succ, [handler(handler, state: state) | handlers]}
+                {true, succ, [handler(handler, state: state)|handlers]}
               {:error, _} = error ->
                 {false, error, handlers}
               other ->
@@ -773,7 +1129,7 @@ defmodule GenEvent do
   defp report_error(handler, reason, state, last_in, name) do
     reason =
       case reason do
-        {:undef, [{m, f, a, _} | _] = mfas} ->
+        {:undef, [{m, f, a, _}|_]=mfas} ->
           cond do
             :code.is_loaded(m) === false ->
               {:"module could not be loaded", mfas}

lib/elixir/lib/gen_event/stream.ex

@@ -1,5 +1,14 @@
 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__{
@@ -13,7 +22,7 @@ defmodule GenEvent.Stream do
 
   @doc false
   def handle_event(event, _state) do
-    # We do this to trick Dialyzer to not complain about non-local returns.
+    # We do this to trick dialyzer to not complain about non-local returns.
     case :erlang.phash2(1, 1) do
       0 -> exit({:bad_event, event})
       1 -> :remove_handler
@@ -22,7 +31,7 @@ defmodule GenEvent.Stream do
 
   @doc false
   def handle_call(msg, _state) do
-    # We do this to trick Dialyzer to not complain about non-local returns.
+    # 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)
@@ -137,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
 

lib/elixir/lib/gen_server.ex

@@ -11,8 +11,8 @@ defmodule GenServer do
   ## Example
 
   The GenServer behaviour abstracts the common client-server interaction.
-  Developers are only required to implement the callbacks and functionality
-  they are interested in.
+  Developers are only required to implement the callbacks and functionality they are
+  interested in.
 
   Let's start with a code example and then explore the available callbacks.
   Imagine we want a GenServer that works like a stack, allowing us to push
@@ -23,12 +23,12 @@ defmodule GenServer do
 
         # Callbacks
 
-        def handle_call(:pop, _from, [h | t]) do
+        def handle_call(:pop, _from, [h|t]) do
           {:reply, h, t}
         end
 
         def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
+          {:noreply, [item|state]}
         end
       end
 
@@ -53,31 +53,16 @@ defmodule GenServer do
   while **cast** messages do not.
 
   Every time you do a `GenServer.call/3`, the client will send a message
-  that must be handled by the `c:handle_call/3` callback in the GenServer.
-  A `cast/2` message must be handled by `c:handle_cast/2`.
+  that must be handled by the `handle_call/3` callback in the GenServer.
+  A `cast/2` message must be handled by `handle_cast/2`.
 
-  ## use GenServer and callbacks
+  ## Callbacks
 
   There are 6 callbacks required to be implemented in a `GenServer`. By
   adding `use GenServer` to your module, Elixir will automatically define
   all 6 callbacks for you, leaving it up to you to implement the ones
   you want to customize.
 
-  `use GenServer` also 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:
-
-    * `:id` - the child specification id, defauts 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 GenServer, restart: :transient, shutdown: 10_000
-
-  See the `Supervisor` docs for more information.
-
   ## Name Registration
 
   Both `start_link/3` and `start/3` support the `GenServer` to register
@@ -88,18 +73,16 @@ defmodule GenServer do
       using `Process.register/2`.
 
     * `{:global, term}`- the GenServer is registered globally with the given
-      term using the functions in the [`:global` module](http://www.erlang.org/doc/man/global.html).
+      term using the functions in the `:global` module.
 
     * `{:via, module, term}` - the GenServer is registered with the given
       mechanism and name. The `:via` option expects a module that exports
       `register_name/2`, `unregister_name/1`, `whereis_name/1` and `send/2`.
-      One such example is the [`:global` module](http://www.erlang.org/doc/man/global.html) which uses these functions
-      for keeping the list of names of processes and their associated PIDs
-      that are available globally for a network of Elixir nodes. Elixir also
-      ships with a local, decentralized and scalable registry called `Registry`
-      for locally storing names that are generated dynamically.
+      One such example is the `:global` module which uses these functions
+      for keeping the list of names of processes and their  associated pid's
+      that are available globally for a network of Erlang nodes.
 
-  For example, we could start and register our `Stack` server locally as follows:
+  For example, we could start and register our Stack server locally as follows:
 
       # Start the server and register it locally with name MyStack
       {:ok, _} = GenServer.start_link(Stack, [:hello], name: MyStack)
@@ -118,11 +101,6 @@ defmodule GenServer do
     * `{:via, module, name}` if the server is registered through an alternative
       registry
 
-  If there is an interest to register dynamic names locally, do not use
-  atoms, as atoms are never garbage collected and therefore dynamically
-  generated atoms won't be garbage collected. For such cases, you can
-  set up your own local registry by using the `Registry` module.
-
   ## Client / Server APIs
 
   Although in the example above we have used `GenServer.start_link/3` and
@@ -151,7 +129,7 @@ defmodule GenServer do
 
         # Server (callbacks)
 
-        def handle_call(:pop, _from, [h | t]) do
+        def handle_call(:pop, _from, [h|t]) do
           {:reply, h, t}
         end
 
@@ -161,7 +139,7 @@ defmodule GenServer do
         end
 
         def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
+          {:noreply, [item|state]}
         end
 
         def handle_cast(request, state) do
@@ -173,113 +151,13 @@ defmodule GenServer do
   the same module. If the server and/or client implementations are growing
   complex, you may want to have them in different modules.
 
-  ## Receiving "regular" messages
+  ## Receiving custom messages
 
   The goal of a `GenServer` is to abstract the "receive" loop for developers,
   automatically handling system messages, support code change, synchronous
   calls and more. Therefore, you should never call your own "receive" inside
   the GenServer callbacks as doing so will cause the GenServer to misbehave.
-
-  Besides the synchronous and asynchronous communication provided by `call/3`
-  and `cast/2`, "regular" messages sent by functions such `Kernel.send/2`,
-  `Process.send_after/4` and similar, can be handled inside the `c:handle_info/2`
-  callback.
-
-  `c:handle_info/2` can be used in many situations, such as handling monitor
-  DOWN messages sent by `Process.monitor/1`. Another use case for `c:handle_info/2`
-  is to perform periodic work, with the help of `Process.send_after/4`:
-
-      defmodule MyApp.Periodically do
-        use GenServer
-
-        def start_link do
-          GenServer.start_link(__MODULE__, %{})
-        end
-
-        def init(state) do
-          schedule_work() # Schedule work to be performed on start
-          {:ok, state}
-        end
-
-        def handle_info(:work, state) do
-          # Do the desired work here
-          schedule_work() # Reschedule once more
-          {:noreply, state}
-        end
-
-        defp schedule_work() do
-          Process.send_after(self(), :work, 2 * 60 * 60 * 1000) # In 2 hours
-        end
-      end
-
-  ## Debugging with the :sys module
-
-  GenServers, as [special processes](http://erlang.org/doc/design_principles/spec_proc.html),
-  can be debugged using the [`:sys` module](http://www.erlang.org/doc/man/sys.html). Through various hooks, this module
-  allows developers to introspect the state of the process and trace
-  system events that happen during its execution, such as received messages,
-  sent replies and state changes.
-
-  Let's explore the basic functions from the [`:sys` module](http://www.erlang.org/doc/man/sys.html) used for debugging:
-
-    * [`:sys.get_state/2`](http://erlang.org/doc/man/sys.html#get_state-2) -
-      allows retrieval of the state of the process. In the case of
-      a GenServer process, it will be the callback module state, as
-      passed into the callback functions as last argument.
-    * [`:sys.get_status/2`](http://erlang.org/doc/man/sys.html#get_status-2) -
-      allows retrieval of the status of the process. This status includes
-      the process dictionary, if the process is running or is suspended,
-      the parent PID, the debugger state, and the state of the behaviour module,
-      which includes the callback module state (as returned by `:sys.get_state/2`).
-      It's possible to change how this status is represented by defining
-      the optional `c:GenServer.format_status/2` callback.
-    * [`:sys.trace/3`](http://erlang.org/doc/man/sys.html#trace-3) -
-      prints all the system events to `:stdio`.
-    * [`:sys.statistics/3`](http://erlang.org/doc/man/sys.html#statistics-3) -
-      manages collection of process statistics.
-    * [`:sys.no_debug/2`](http://erlang.org/doc/man/sys.html#no_debug-2) -
-      turns off all debug handlers for the given process. It is very important
-      to switch off debugging once we're done. Excessive debug handlers or
-      those that should be turned off, but weren't, can seriously damage
-      the performance of the system.
-    * [`:sys.suspend/2`](http://erlang.org/doc/man/sys.html#suspend-2) - allows
-      to suspend a process so that it only replies to system messages but no
-      other messages. A suspended process can be reactivated via
-      [`:sys.resume/2`](http://erlang.org/doc/man/sys.html#resume-2).
-
-  Let's see how we could use those functions for debugging the stack server
-  we defined earlier.
-
-      iex> {:ok, pid} = Stack.start_link([])
-      iex> :sys.statistics(pid, true) # turn on collecting process statistics
-      iex> :sys.trace(pid, true) # turn on event printing
-      iex> Stack.push(pid, 1)
-      *DBG* <0.122.0> got cast {push,1}
-      *DBG* <0.122.0> new state [1]
-      :ok
-      iex> :sys.get_state(pid)
-      [1]
-      iex> Stack.pop(pid)
-      *DBG* <0.122.0> got call pop from <0.80.0>
-      *DBG* <0.122.0> sent 1 to <0.80.0>, new state []
-      1
-      iex> :sys.statistics(pid, :get)
-      {:ok,
-       [start_time: {{2016, 7, 16}, {12, 29, 41}},
-        current_time: {{2016, 7, 16}, {12, 29, 50}},
-        reductions: 117, messages_in: 2, messages_out: 0]}
-      iex> :sys.no_debug(pid) # turn off all debug handlers
-      :ok
-      iex> :sys.get_status(pid)
-      {:status, #PID<0.122.0>, {:module, :gen_server},
-       [["$initial_call": {Stack, :init, 1},            # pdict
-         "$ancestors": [#PID<0.80.0>, #PID<0.51.0>]],
-        :running,                                       # :running | :suspended
-        #PID<0.80.0>,                                   # parent
-        [],                                             # debugger state
-        [header: 'Status for generic server <0.122.0>', # module status
-         data: [{'Status', :running}, {'Parent', #PID<0.80.0>},
-           {'Logged events', []}], data: [{'State', [1]}]]]}
+  If you want to receive custom messages, always receive them in `handle_info/2`.
 
   ## Learn more
 
@@ -294,7 +172,7 @@ defmodule GenServer do
   """
 
   @doc """
-  Invoked when the server is started. `start_link/3` or `start/3` will
+  Invoked when the server is started. `start_link/3` (or `start/3`) will
   block until it returns.
 
   `args` is the argument term (second argument) passed to `start_link/3`.
@@ -308,10 +186,10 @@ defmodule GenServer do
 
   Returning `{:ok, state, :hibernate}` is similar to
   `{:ok, state}` except the process is hibernated before entering the loop. See
-  `c:handle_call/3` for more information on hibernation.
+  `handle_call/3` for more information on hibernation.
 
   Returning `:ignore` will cause `start_link/3` to return `:ignore` and the
-  process will exit normally without entering the loop or calling `c:terminate/2`.
+  process will exit normally without entering the loop or calling `terminate/2`.
   If used when part of a supervision tree the parent supervisor will not fail
   to start nor immediately try to restart the `GenServer`. The remainder of the
   supervision tree will be (re)started and so the `GenServer` should not be
@@ -319,14 +197,14 @@ defmodule GenServer do
   `Supervisor.restart_child/2` as the child specification is saved in the parent
   supervisor. The main use cases for this are:
 
-    * The `GenServer` is disabled by configuration but might be enabled later.
-    * An error occurred and it will be handled by a different mechanism than the
-     `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2`
-      after a delay to attempt a restart.
+  - The `GenServer` is disabled by configuration but might be enabled later.
+  - An error occured and it will be handled by a different mechanism than the
+  `Supervisor`. Likely this approach involves calling `Supervisor.restart_child/2`
+  after a delay to attempt a restart.
 
   Returning `{:stop, reason}` will cause `start_link/3` to return
   `{:error, reason}` and the process to exit with reason `reason` without
-  entering the loop or calling `c:terminate/2`.
+  entering the loop or calling `terminate/2`.
   """
   @callback init(args :: term) ::
     {:ok, state} |
@@ -339,7 +217,7 @@ defmodule GenServer do
   reply is received (unless the call times out or nodes are disconnected).
 
   `request` is the request message sent by a `call/3`, `from` is a 2-tuple
-  containing the caller's PID and a term that uniquely identifies the call, and
+  containing the caller's pid and a term that uniquely identifies the call, and
   `state` is the current state of the `GenServer`.
 
   Returning `{:reply, reply, new_state}` sends the response `reply` to the
@@ -351,10 +229,10 @@ defmodule GenServer do
 
   Returning `{:reply, reply, new_state, :hibernate}` is similar to
   `{:reply, reply, new_state}` except the process is hibernated and will
-  continue the loop once a message is in its message queue. If a message is
-  already in the message queue this will be immediately. Hibernating a
-  `GenServer` causes garbage collection and leaves a continuous heap that
-  minimises the memory used by the process.
+  continue the loop once a message is its message queue. If a message is already
+  in the message queue this will be immediately. Hibernating a `GenServer`
+  causes garbage collection and leaves a continuous heap that minimises the
+  memory used by the process.
 
   Hibernating should not be used aggressively as too much time could be spent
   garbage collecting. Normally it should only be used when a message is not
@@ -367,11 +245,11 @@ defmodule GenServer do
 
   There are three main use cases for not replying using the return value:
 
-    * To reply before returning from the callback because the response is known
-      before calling a slow function.
-    * To reply after returning from the callback because the response is not yet
-      available.
-    * To reply from another process, such as a task.
+  - To reply before returning from the callback because the response is known
+  before calling a slow function.
+  - To reply after returning from the callback because the response is not yet
+  available.
+  - To reply from another process, such as a task.
 
   When replying from another process the `GenServer` should exit if the other
   process exits without replying as the caller will be blocking awaiting a
@@ -381,15 +259,12 @@ defmodule GenServer do
   `{:noreply, new_state}` except a timeout or hibernation occurs as with a
   `:reply` tuple.
 
-  Returning `{:stop, reason, reply, new_state}` stops the loop and `c:terminate/2`
+  Returning `{:stop, reason, reply, new_state}` stops the loop and `terminate/2`
   is called with reason `reason` and state `new_state`. Then the `reply` is sent
   as the response to call and the process exits with reason `reason`.
 
   Returning `{:stop, reason, new_state}` is similar to
   `{:stop, reason, reply, new_state}` except a reply is not sent.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:stop, {:bad_call, request}, state}`.
   """
   @callback handle_call(request :: term, from, state :: term) ::
     {:reply, reply, new_state} |
@@ -408,19 +283,16 @@ defmodule GenServer do
   Returning `{:noreply, new_state}` continues the loop with new state `new_state`.
 
   Returning `{:noreply, new_state, timeout}` is similar to
-  `{:noreply, new_state}` except `handle_info(:timeout, new_state)` will be
-  called after `timeout` milliseconds if no messages are received.
+  `{:noreply, reply, new_state}` except `handle_info(:timeout, new_state)` will
+  be called after `timeout` milliseconds if no messages are received.
 
   Returning `{:noreply, new_state, :hibernate}` is similar to
   `{:noreply, new_state}` except the process is hibernated before continuing the
-  loop. See `c:handle_call/3` for more information.
+  loop. See `handle_call/3` for more information.
 
-  Returning `{:stop, reason, new_state}` stops the loop and `c:terminate/2` is
+  Returning `{:stop, reason, new_state}` stops the loop and `terminate/2` is
   called with the reason `reason` and state `new_state`. The process exits with
   reason `reason`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:stop, {:bad_cast, request}, state}`.
   """
   @callback handle_cast(request :: term, state :: term) ::
     {:noreply, new_state} |
@@ -433,10 +305,7 @@ defmodule GenServer do
   `msg` is the message and `state` is the current state of the `GenServer`. When
   a timeout occurs the message is `:timeout`.
 
-  Return values are the same as `c:handle_cast/2`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:noreply, state}`.
+  Return values are the same as `handle_cast/2`.
   """
   @callback handle_info(msg :: :timeout | term, state :: term) ::
     {:noreply, new_state} |
@@ -449,38 +318,33 @@ defmodule GenServer do
   `reason` is exit reason and `state` is the current state of the `GenServer`.
   The return value is ignored.
 
-  `c:terminate/2` is called if a callback (except `c:init/1`) does one of the
-  following:
+  `terminate/2` is called if a callback (except `init/1`) returns a `:stop`
+  tuple, raises, calls `Kernel.exit/1` or returns an invalid value. It may also
+  be called if the `GenServer` traps exits using `Process.flag/2` *and* the
+  parent process sends an exit signal.
 
-    * returns a `:stop` tuple
-    * raises
-    * calls `Kernel.exit/1`
-    * returns an invalid value
-    * the `GenServer` traps exits (using `Process.flag/2`) *and* the parent
-      process sends an exit signal
-
-  If part of a supervision tree, a `GenServer`'s `Supervisor` will send an exit
+  If part of a supervision tree a `GenServer`'s `Supervisor` will send an exit
   signal when shutting it down. The exit signal is based on the shutdown
   strategy in the child's specification. If it is `:brutal_kill` the `GenServer`
-  is killed and so `c:terminate/2` is not called. However if it is a timeout the
+  is killed and so `terminate/2` is not called. However if it is a timeout the
   `Supervisor` will send the exit signal `:shutdown` and the `GenServer` will
-  have the duration of the timeout to call `c:terminate/2` - if the process is
+  have the duration of the timeout to call `terminate/2` - if the process is
   still alive after the timeout it is killed.
 
   If the `GenServer` receives an exit signal (that is not `:normal`) from any
   process when it is not trapping exits it will exit abruptly with the same
-  reason and so not call `c:terminate/2`. Note that a process does *NOT* trap
+  reason and so not call `terminate/2`. Note that a process does *NOT* trap
   exits by default and an exit signal is sent when a linked process exits or its
   node is disconnected.
 
-  Therefore it is not guaranteed that `c:terminate/2` is called when a `GenServer`
+  Therefore it is not guaranteed that `terminate/2` is called when a `GenServer`
   exits. For such reasons, we usually recommend important clean-up rules to
   happen in separated processes either by use of monitoring or by links
   themselves. For example if the `GenServer` controls a `port` (e.g.
-  `:gen_tcp.socket`) or `t:File.io_device/0`, they will be closed on receiving a
-  `GenServer`'s exit signal and do not need to be closed in `c:terminate/2`.
+  `:gen_tcp.socket`) or `File.io_device`, they will be closed on receiving a
+  `GenServer`'s exit signal and do not need to be closed in `terminate/2`.
 
-  If `reason` is not `:normal`, `:shutdown`, nor `{:shutdown, term}` an error is
+  If `reason` is not `:normal`, `:shutdown` nor `{:shutdown, term}` an error is
   logged.
   """
   @callback terminate(reason, state :: term) ::
@@ -502,35 +366,13 @@ defmodule GenServer do
   Returning `{:error, reason}` fails the code change with reason `reason` and
   the state remains as the previous state.
 
-  If `c:code_change/3` raises the code change fails and the loop will continue
+  If `code_change/3` raises the code change fails and the loop will continue
   with its previous state. Therefore this callback does not usually contain side effects.
   """
   @callback code_change(old_vsn, state :: term, extra :: term) ::
     {:ok, new_state :: term} |
     {:error, reason :: term} when old_vsn: term | {:down, term}
 
-  @doc """
-  Invoked in some cases to retrieve a formatted version of the `GenServer` status.
-
-  This callback can be useful to control the *appearance* of the status of the
-  `GenServer`. For example, it can be used to return a compact representation of
-  the `GenServer`'s state to avoid having large state terms printed.
-
-    * one of `:sys.get_status/1` or `:sys.get_status/2` is invoked to get the
-      status of the `GenServer`; in such cases, `reason` is `:normal`
-
-    * the `GenServer` terminates abnormally and logs an error; in such cases,
-      `reason` is `:terminate`
-
-  `pdict_and_state` is a two-elements list `[pdict, state]` where `pdict` is a
-  list of `{key, value}` tuples representing the current process dictionary of
-  the `GenServer` and `state` is the current state of the `GenServer`.
-  """
-  @callback format_status(reason, pdict_and_state :: list) ::
-    term when reason: :normal | :terminate
-
-  @optional_callbacks format_status: 2
-
   @typedoc "Return values of `start*` functions"
   @type on_start :: {:ok, pid} | :ignore | {:error, {:already_started, pid} | term}
 
@@ -555,30 +397,15 @@ defmodule GenServer do
   @typedoc """
   Tuple describing the client of a call request.
 
-  `pid` is the PID of the caller and `tag` is a unique term used to identify the
+  `pid` is the pid of the caller and `tag` is a unique term used to identify the
   call.
   """
   @type from :: {pid, tag :: term}
 
   @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      @behaviour GenServer
-
-      spec = [
-        id: opts[:id] || __MODULE__,
-        start: Macro.escape(opts[:start]) || quote(do: {__MODULE__, :start_link, [arg]}),
-        restart: opts[:restart] || :permanent,
-        shutdown: opts[:shutdown] || 5000,
-        type: :worker
-      ]
-
-      @doc false
-      def child_spec(arg) do
-        %{unquote_splicing(spec)}
-      end
-
-      defoverridable child_spec: 1
+  defmacro __using__(_) do
+    quote location: :keep do
+      @behaviour :gen_server
 
       @doc false
       def init(args) do
@@ -587,43 +414,26 @@ defmodule GenServer do
 
       @doc false
       def handle_call(msg, _from, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
         # We do this to trick Dialyzer to not complain about non-local returns.
+        reason = {:bad_call, msg}
         case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to call GenServer #{inspect proc} but no handle_call/3 clause was provided"
-          1 -> {:stop, {:bad_call, msg}, state}
+          0 -> exit(reason)
+          1 -> {:stop, reason, state}
         end
       end
 
       @doc false
-      def handle_info(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-        :error_logger.error_msg('~p ~p received unexpected message in handle_info/2: ~p~n',
-                                [__MODULE__, proc, msg])
+      def handle_info(_msg, state) do
         {:noreply, state}
       end
 
       @doc false
       def handle_cast(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
         # We do this to trick Dialyzer to not complain about non-local returns.
+        reason = {:bad_cast, msg}
         case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to cast GenServer #{inspect proc} but no handle_cast/2 clause was provided"
-          1 -> {:stop, {:bad_cast, msg}, state}
+          0 -> exit(reason)
+          1 -> {:stop, reason, state}
         end
       end
 
@@ -637,7 +447,8 @@ defmodule GenServer do
         {:ok, state}
       end
 
-      defoverridable GenServer
+      defoverridable [init: 1, handle_call: 3, handle_info: 2,
+                      handle_cast: 2, terminate: 2, code_change: 3]
     end
   end
 
@@ -646,40 +457,38 @@ defmodule GenServer do
 
   This is often used to start the `GenServer` as part of a supervision tree.
 
-  Once the server is started, the `c:init/1` function of the given `module` is
-  called with `args` as its arguments to initialize the server. To ensure a
-  synchronized start-up procedure, this function does not return until `c:init/1`
-  has returned.
+  Once the server is started, it calls the `init/1` function in the given `module`
+  passing the given `args` to initialize it. To ensure a synchronized start-up
+  procedure, this function does not return until `init/1` has returned.
 
   Note that a `GenServer` started with `start_link/3` is linked to the
-  parent process and will exit in case of crashes from the parent. The GenServer
-  will also exit due to the `:normal` reasons in case it is configured to trap
-  exits in the `c:init/1` callback.
+  parent process and will exit in case of crashes. The GenServer will also
+  exit due to the `:normal` reasons in case it is configured to trap exits
+  in the `init/1` callback.
 
   ## Options
 
-    * `:name` - used for name registration as described in the "Name
-      registration" section of the module documentation
+  The `:name` option is used for name registration as described in the module
+  documentation. If the option `:timeout` option is present, the server is
+  allowed to spend the given milliseconds initializing or it will be
+  terminated and the start function will return `{:error, :timeout}`.
 
-    * `:timeout` - if present, the server is allowed to spend the given amount of
-      milliseconds initializing or it will be terminated and the start function
-      will return `{:error, :timeout}`
+  If the `:debug` option is present, the corresponding function in the
+  [`:sys` module](http://www.erlang.org/doc/man/sys.html) will be invoked.
 
-    * `:debug` - if present, the corresponding function in the [`:sys` module](http://www.erlang.org/doc/man/sys.html) is invoked
-
-    * `:spawn_opt` - if present, its value is passed as options to the
-      underlying process as in `Process.spawn/4`
+  If the `:spawn_opt` option is present, its value will be passed as options
+  to the underlying process as in `Process.spawn/4`.
 
   ## Return values
 
-  If the server is successfully created and initialized, this function returns
-  `{:ok, pid}`, where `pid` is the PID of the server. If a process with the
-  specified server name already exists, this function returns
-  `{:error, {:already_started, pid}}` with the PID of that process.
+  If the server is successfully created and initialized, the function returns
+  `{:ok, pid}`, where pid is the pid of the server. If a process with the
+  specified server name already exists, the function returns
+  `{:error, {:already_started, pid}}` with the pid of that process.
 
-  If the `c:init/1` callback fails with `reason`, this function returns
+  If the `init/1` callback fails with `reason`, the function returns
   `{:error, reason}`. Otherwise, if it returns `{:stop, reason}`
-  or `:ignore`, the process is terminated and this function returns
+  or `:ignore`, the process is terminated and the function returns
   `{:error, reason}` or `:ignore`, respectively.
   """
   @spec start_link(module, any, options) :: on_start
@@ -703,34 +512,22 @@ defmodule GenServer do
         :gen.start(:gen_server, link, module, args, opts)
       {atom, opts} when is_atom(atom) ->
         :gen.start(:gen_server, link, {:local, atom}, module, args, opts)
-      {{:global, _term} = tuple, opts} ->
-        :gen.start(:gen_server, link, tuple, module, args, opts)
-      {{:via, via_module, _term} = tuple, opts} when is_atom(via_module) ->
-        :gen.start(:gen_server, link, tuple, module, args, opts)
-      {other, _} ->
-        raise ArgumentError, """
-        expected :name option to be one of:
-
-          * nil
-          * atom
-          * {:global, term}
-          * {:via, module, term}
-
-        Got: #{inspect(other)}
-        """
+      {other, opts} when is_tuple(other) ->
+        :gen.start(:gen_server, link, other, module, args, opts)
     end
   end
 
   @doc """
-  Synchronously stops the server with the given `reason`.
+  Stops the server with the given `reason`.
 
-  The `c:terminate/2` callback of the given `server` will be invoked before
-  exiting. This function returns `:ok` if the server terminates with the
-  given reason; if it terminates with another reason, the call exits.
+  The `terminate/2` callback will be invoked before exiting.
+  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 is logged.
+  `{:shutdown, _}`, an error report will be logged.
   """
   @spec stop(server, reason :: term, timeout) :: :ok
   def stop(server, reason \\ :normal, timeout \\ :infinity) do
@@ -741,52 +538,50 @@ defmodule GenServer do
   Makes a synchronous call to the `server` and waits for its reply.
 
   The client sends the given `request` to the server and waits until a reply
-  arrives or a timeout occurs. `c:handle_call/3` will be called on the server
+  arrives or a timeout occurs. `handle_call/3` will be called on the server
   to handle the request.
 
-  `server` can be any of the values described in the "Name registration"
-  section of the documentation for this module.
+  The server can be any of the values described in the `Name Registration`
+  section of the module documentation.
 
   ## Timeouts
 
-  `timeout` is an integer greater than zero which specifies how many
+  The `timeout` is an integer greater than zero which specifies how many
   milliseconds to wait for a reply, or the atom `:infinity` to wait
-  indefinitely. The default value is `5000`. If no reply is received within
-  the specified time, the function call fails and the caller exits. If the
-  caller catches the failure and continues running, and the server is just late
-  with the reply, it may arrive at any time later into the caller's message
-  queue. The caller must in this case be prepared for this and discard any such
-  garbage messages that are two-element tuples with a reference as the first
-  element.
+  indefinitely. The default value is 5000. If no reply is received within
+  the specified time, the function call fails. If the caller catches the
+  failure and continues running, and the server is just late with the reply,
+  it may arrive at any time later into the caller's message queue. The caller
+  must in this case be prepared for this and discard any such garbage messages
+  that are two-element tuples with a reference as the first element.
   """
   @spec call(server, term, timeout) :: term
   def call(server, request, timeout \\ 5000) do
-    case whereis(server) do
-      nil ->
-        exit({:noproc, {__MODULE__, :call, [server, request, timeout]}})
-      pid when pid == self() ->
-        exit({:calling_self, {__MODULE__, :call, [server, request, timeout]}})
-      pid ->
-        try do
-          :gen.call(pid, :"$gen_call", request, timeout)
-        catch
-          :exit, reason ->
-            exit({reason, {__MODULE__, :call, [server, request, timeout]}})
-        else
-          {:ok, res} -> res
-        end
+    try do
+      :gen.call(server, :"$gen_call", request, timeout)
+    catch
+      :exit, reason ->
+        exit({reason, {__MODULE__, :call, [server, request, timeout]}})
+    else
+      {:ok, res} -> res
     end
   end
 
   @doc """
   Sends an asynchronous request to the `server`.
 
-  This function always returns `:ok` regardless of whether
-  the destination `server` (or node) exists. Therefore it
+  This function returns `:ok` without waiting for the
+  destination `server` to handle the message. Therefore it
   is unknown whether the destination `server` successfully
-  handled the message.
+  handled the message. If the `server` is an atom without
+  an associated process an `ArgumentError` is raised. In
+  all other cases the function returns `:ok` regardless of
+  whether the destination `server` (or node) exists. Note
+  that `{name, node()}` can be used when an exception is
+  not desired if no process is locally associated with the
+  atom `name`.
 
-  `c:handle_cast/2` will be called on the server to handle
+  `handle_cast/2` will be called on the server to handle
   the request. In case the `server` is on a node which is
   not yet connected to the caller one, the call is going to
   block until a connection happens. This is different than
@@ -824,13 +619,13 @@ defmodule GenServer do
   @doc """
   Casts all servers locally registered as `name` at the specified nodes.
 
-  This function returns immediately and ignores nodes that do not exist, or where the
+  The function returns immediately and ignores nodes that do not exist, or where the
   server name does not exist.
 
   See `multi_call/4` for more information.
   """
   @spec abcast([node], name :: atom, term) :: :abcast
-  def abcast(nodes \\ [node() | Node.list()], name, request) when is_list(nodes) and is_atom(name) do
+  def abcast(nodes \\ nodes(), name, request) when is_list(nodes) and is_atom(name) do
     msg = cast_msg(request)
     _   = for node <- nodes, do: do_send({name, node}, msg)
     :abcast
@@ -841,83 +636,49 @@ defmodule GenServer do
   end
 
   defp do_send(dest, msg) do
-    try do
-      send(dest, msg)
-      :ok
-    catch
-      _, _ -> :ok
-    end
+    send(dest, msg)
+    :ok
   end
 
   @doc """
   Calls all servers locally registered as `name` at the specified `nodes`.
 
-  First, the `request` is sent to every node in `nodes`; then, the caller waits
-  for the replies. This function returns a two-element tuple `{replies,
-  bad_nodes}` where:
+  The `request` is first sent to every node and then we wait for the
+  replies. This function returns a tuple containing the node and its reply
+  as first element and all bad nodes as second element. The bad nodes is a
+  list of nodes that either did not exist, or where a server with the given
+  `name` did not exist or did not reply.
 
-    * `replies` - is a list of `{node, reply}` tuples where `node` is the node
-      that replied and `reply` is its reply
-    * `bad_nodes` - is a list of nodes that either did not exist or where a
-      server with the given `name` did not exist or did not reply
-
-  `nodes` is a list of node names to which the request is sent. The default
-  value is the list of all known nodes (including this node).
+  Nodes is a list of node names to which the request is sent. The default
+  value is the list of all known nodes.
 
   To avoid that late answers (after the timeout) pollute the caller's message
   queue, a middleman process is used to do the actual calls. Late answers will
   then be discarded when they arrive to a terminated process.
-
-  ## Examples
-
-  Assuming the `Stack` GenServer mentioned in the docs for the `GenServer`
-  module is registered as `Stack` in the `:"foo@my-machine"` and
-  `:"bar@my-machine"` nodes:
-
-      GenServer.multi_call(Stack, :pop)
-      #=> {[{:"foo@my-machine", :hello}, {:"bar@my-machine", :world}], []}
-
   """
   @spec multi_call([node], name :: atom, term, timeout) ::
                   {replies :: [{node, term}], bad_nodes :: [node]}
-  def multi_call(nodes \\ [node() | Node.list()], name, request, timeout \\ :infinity) do
+  def multi_call(nodes \\ nodes(), name, request, timeout \\ :infinity) do
     :gen_server.multi_call(nodes, name, request, timeout)
   end
 
   @doc """
   Replies to a client.
 
-  This function can be used to explicitly send a reply to a client that called
-  `call/3` or `multi_call/4` when the reply cannot be specified in the return
-  value of `c:handle_call/3`.
+  This function can be used by a server to explicitly send a reply to a
+  client that called `call/3` or `multi_call/4`. When the reply cannot be
+  defined in the return value of `handle_call/3`.
 
-  `client` must be the `from` argument (the second argument) accepted by
-  `c:handle_call/3` callbacks. `reply` is an arbitrary term which will be given
-  back to the client as the return value of the call.
-
-  Note that `reply/2` can be called from any process, not just the GenServer
-  that originally received the call (as long as that GenServer communicated the
-  `from` argument somehow).
+  The `client` must be the `from` argument (the second argument) received
+  in `handle_call/3` callbacks. Reply is an arbitrary term which will be
+  given back to the client as the return value of the call.
 
   This function always returns `:ok`.
-
-  ## Examples
-
-      def handle_call(:reply_in_one_second, from, state) do
-        Process.send_after(self(), {:reply, from}, 1_000)
-        {:noreply, state}
-      end
-
-      def handle_info({:reply, from}, state) do
-        GenServer.reply(from, :one_second_has_passed)
-        {:noreply, state}
-      end
-
   """
   @spec reply(from, term) :: :ok
   def reply(client, reply)
 
-  def reply({to, tag}, reply) when is_pid(to) do
+  def reply({to, tag}, reply) do
     try do
       send(to, {tag, reply})
       :ok
@@ -927,12 +688,10 @@ defmodule GenServer do
   end
 
   @doc """
-  Returns the `pid` or `{name, node}` of a GenServer process, or `nil` if
-  no process is associated with the given `server`.
+  Returns the `pid` or `{name, node}` of a GenServer process.
+  Returns `nil` if no process is associated with the given name.
 
-  ## Examples
-
-  For example, to lookup a server process, monitor it and send a cast to it:
+  For example, to lookup a server process, monitor it and send a cast:
 
       process = GenServer.whereis(server)
       monitor = Process.monitor(process)
@@ -940,33 +699,32 @@ defmodule GenServer do
 
   """
   @spec whereis(server) :: pid | {atom, node} | nil
-  def whereis(server)
-
   def whereis(pid) when is_pid(pid), do: pid
-
   def whereis(name) when is_atom(name) do
     Process.whereis(name)
   end
-
   def whereis({:global, name}) do
     case :global.whereis_name(name) do
       pid when is_pid(pid) -> pid
       :undefined           -> nil
     end
   end
-
   def whereis({:via, mod, name}) do
     case apply(mod, :whereis_name, [name]) do
       pid when is_pid(pid) -> pid
       :undefined           -> nil
     end
   end
-
   def whereis({name, local}) when is_atom(name) and local == node() do
     Process.whereis(name)
   end
-
   def whereis({name, node} = server) when is_atom(name) and is_atom(node) do
     server
   end
+
+  @compile {:inline, [nodes: 0]}
+
+  defp nodes do
+    [node()|:erlang.nodes()]
+  end
 end

lib/elixir/lib/hash_dict.ex

@@ -5,9 +5,6 @@ defmodule HashDict do
   Use the `Map` module instead.
   """
 
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-
   use Dict
 
   @node_bitmap 0b111
@@ -93,7 +90,7 @@ 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
@@ -104,11 +101,11 @@ defmodule HashDict 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, [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}
@@ -122,11 +119,11 @@ defmodule HashDict 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, [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}
@@ -141,16 +138,16 @@ defmodule HashDict do
     case elem(node, index) do
       [] ->
         :error
-      [^key | value] ->
+      [^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}
+            {put_elem(node, index, [k|v]), value}
           {n, value} ->
             {put_elem(node, index, {k, v, n}), value}
           :error ->
@@ -162,9 +159,9 @@ defmodule HashDict do
   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] ->
+        [k|v] ->
           case put_elem(node, unquote(index), []) do
-            @node_template -> [k | v]
+            @node_template -> [k|v]
             n -> {k, v, n}
           end
         {k, v, n} ->
@@ -187,7 +184,7 @@ defmodule HashDict do
     next.(acc)
   end
 
-  defp do_reduce_each([k | v], {:cont, acc}, fun, next) do
+  defp do_reduce_each([k|v], {:cont, acc}, fun, next) do
     next.(fun.({k, v}, acc))
   end
 
@@ -221,35 +218,16 @@ 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 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
     {original, fn
-      dict, {:cont, {key, value}} -> module.put(dict, key, value)
+      dict, {:cont, {k, v}} -> HashDict.put(dict, k, v)
       dict, :done -> dict
       _, :halt -> :ok
     end}
@@ -260,8 +238,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

@@ -5,8 +5,7 @@ defmodule HashSet do
   Use the `MapSet` module instead.
   """
 
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
+  @behaviour Set
 
   @node_bitmap 0b111
   @node_shift 3
@@ -45,7 +44,7 @@ defmodule HashSet do
   end
 
   def to_list(set) do
-    set_fold(set, [], &[&1 | &2]) |> :lists.reverse
+    set_fold(set, [], &[&1|&2]) |> :lists.reverse
   end
 
   def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
@@ -113,10 +112,10 @@ defmodule HashSet do
   defp do_member?(node, term, hash) do
     index = key_mask(hash)
     case elem(node, index) do
-      []          -> false
-      [^term | _] -> true
-      [_]         -> false
-      [_ | n]     -> do_member?(n, term, key_shift(hash))
+      []        -> false
+      [^term|_] -> true
+      [_]       -> false
+      [_|n]     -> do_member?(n, term, key_shift(hash))
     end
   end
 
@@ -125,14 +124,14 @@ defmodule HashSet do
     case elem(node, index) do
       [] ->
         {put_elem(node, index, [term]), 1}
-      [^term | _] ->
+      [^term|_] ->
         {node, 0}
       [t] ->
         n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
-        {put_elem(node, index, [t | n]), 1}
-      [t | n] ->
+        {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}
+        {put_elem(node, index, [t|n]), counter}
     end
   end
 
@@ -145,14 +144,14 @@ defmodule HashSet do
         {:ok, put_elem(node, index, [])}
       [_] ->
         :error
-      [^term | n] ->
+      [^term|n] ->
         {:ok, put_elem(node, index, do_compact_node(n))}
-      [t | 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])}
+            {:ok, put_elem(node, index, [t|n])}
           :error ->
             :error
         end
@@ -165,19 +164,19 @@ defmodule HashSet do
         [t] ->
           case put_elem(node, unquote(index), []) do
             @node_template -> [t]
-            n -> [t | n]
+            n -> [t|n]
           end
-        [t | n] ->
-          [t | put_elem(node, unquote(index), do_compact_node(n))]
+        [t|n] ->
+          [t|put_elem(node, unquote(index), do_compact_node(n))]
       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([t | n], acc, fun), do: do_fold(n, fun.(t, acc), fun, @node_size)
+  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
     acc = do_fold_each(:erlang.element(count, node), acc, fun)
@@ -206,7 +205,7 @@ defmodule HashSet do
     next.(fun.(t, acc))
   end
 
-  defp do_reduce_each([t | n], {:cont, acc}, fun, next) do
+  defp do_reduce_each([t|n], {:cont, acc}, fun, next) do
     do_reduce(n, fun.(t, acc), fun, @node_size, next)
   end
 
@@ -236,31 +235,15 @@ 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 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
     {original, fn
-      set, {:cont, term} -> module.put(set, term)
+      set, {:cont, x} -> HashSet.put(set, x)
       set, :done -> set
       _, :halt -> :ok
     end}
@@ -271,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

@@ -27,7 +27,7 @@ defprotocol Inspect do
         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
@@ -55,249 +55,247 @@ defprotocol Inspect do
   # Handle structs in Any
   @fallback_to_any true
 
-  def inspect(term, opts)
+  def inspect(thing, opts)
 end
 
 defimpl Inspect, for: Atom do
   require Macro
 
-  def inspect(atom, opts) do
-    color(inspect(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) when is_nil(atom) or is_boolean(atom) do
-    Atom.to_string(atom)
-  end
-
-  def inspect(atom) when is_atom(atom) do
+  def inspect(atom) do
     binary = Atom.to_string(atom)
 
-    case Macro.classify_identifier(atom) do
-      :alias ->
-        case binary do
-          binary when binary in ["Elixir", "Elixir.Elixir"] ->
-            binary
-          "Elixir.Elixir." <> _rest ->
-            binary
-          "Elixir." <> rest ->
-            rest
+    cond do
+      valid_ref_identifier?(binary) ->
+        if only_elixir?(binary) do
+          binary
+        else
+          "Elixir." <> rest = binary
+          rest
         end
-      type when type in [:callable, :not_callable] ->
+      valid_atom_identifier?(binary) ->
         ":" <> binary
-      :other ->
-        {escaped, _} = Inspect.BitString.escape(binary, ?")
-        IO.iodata_to_binary [?:, ?", escaped, ?"]
+      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 escape(term, ?", printable_limit) do
-          {escaped, ""} -> [?", escaped, ?"]
-          {escaped, _} -> [?", escaped, ?", " <> ..."]
-        end
-      color(IO.iodata_to_binary(inspected), :string, opts)
+  def inspect(thing, %Inspect.Opts{binaries: bins} = opts) when is_binary(thing) do
+    if bins == :as_strings or (bins == :infer and String.printable?(thing)) do
+      <<?", escape(thing, ?")::binary, ?">>
     else
-      inspect_bitstring(term, opts)
+      inspect_bitstring(thing, opts)
     end
   end
 
-  def inspect(term, opts) do
-    inspect_bitstring(term, opts)
+  def inspect(thing, opts) do
+    inspect_bitstring(thing, opts)
   end
 
   ## Escaping
 
   @doc false
   def escape(other, char) do
-    escape(other, char, :infinity, [])
+    escape(other, char, <<>>)
   end
 
-  @doc false
-  def escape(other, char, count) do
-    escape(other, char, count, [])
+  defp escape(<<char, t::binary >>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, char>>)
   end
-
-  defp escape(<<_, _::binary>> = binary, _char, 0, acc) do
-    {acc, binary}
+  defp escape(<<?#, ?{, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?#, ?{>>)
   end
-  defp escape(<<char, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | [?\\, char]])
+  defp escape(<<?\a, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?a>>)
   end
-  defp escape(<<?#, ?{, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\\#{'])
+  defp escape(<<?\b, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?b>>)
   end
-  defp escape(<<?\a, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\a'])
+  defp escape(<<?\d, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?d>>)
   end
-  defp escape(<<?\b, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\b'])
+  defp escape(<<?\e, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?e>>)
   end
-  defp escape(<<?\d, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\d'])
+  defp escape(<<?\f, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?f>>)
   end
-  defp escape(<<?\e, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\e'])
+  defp escape(<<?\n, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?n>>)
   end
-  defp escape(<<?\f, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\f'])
+  defp escape(<<?\r, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?r>>)
   end
-  defp escape(<<?\n, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\n'])
+  defp escape(<<?\\, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?\\>>)
   end
-  defp escape(<<?\r, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\r'])
+  defp escape(<<?\t, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?t>>)
   end
-  defp escape(<<?\\, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\\\'])
+  defp escape(<<?\v, t::binary>>, char, binary) do
+    escape(t, char, <<binary::binary, ?\\, ?v>>)
   end
-  defp escape(<<?\t, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\t'])
+  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(<<?\v, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\v'])
-  end
-  defp escape(<<h::utf8, t::binary>>, char, count, acc)
-       when h in 0x20..0x7E
-       when h in 0xA0..0xD7FF
-       when h in 0xE000..0xFFFD
-       when h in 0x10000..0x10FFFF do
-    escape(t, char, decrement(count), [acc | <<h::utf8>>])
-  end
-  defp escape(<<h, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | escape_char(h)])
-  end
-  defp escape(<<>>, _char, _count, acc) do
-    {acc, <<>>}
+  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'
+    <<?\\, ?0>>
   end
 
   def escape_char(char) when char < 0x100 do
     <<a::4, b::4>> = <<char::8>>
-    ['\\x', to_hex(a), to_hex(b)]
+    <<?\\, ?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), ?}]
+    <<?\\, ?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), ?}]
+    <<?\\, ?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 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
-    color("<<>>", :binary, opts)
-  end
-
   defp inspect_bitstring(bitstring, opts) do
-    left = color("<<", :binary, opts)
-    right = color(">>", :binary, opts)
-    nest surround(left, each_bit(bitstring, opts.limit, opts), right), 1
+    each_bit(bitstring, opts.limit, "<<") <> ">>"
   end
 
-  defp each_bit(_, 0, _) do
-    "..."
+  defp each_bit(_, 0, acc) do
+    acc <> "..."
   end
 
-  defp each_bit(<<>>, _counter, _opts) do
-    :doc_nil
+  defp each_bit(<<h, t::bitstring>>, counter, acc) when t != <<>> do
+    each_bit(t, decrement(counter), acc <> Integer.to_string(h) <> ", ")
   end
 
-  defp each_bit(<<h::8>>, _counter, opts) do
-    Inspect.Integer.inspect(h, opts)
+  defp each_bit(<<h::8>>, _counter, acc) do
+    acc <> Integer.to_string(h)
   end
 
-  defp each_bit(<<h, t::bitstring>>, counter, opts) do
-    glue(concat(Inspect.Integer.inspect(h, opts), ","),
-         each_bit(t, decrement(counter), opts))
+  defp each_bit(<<>>, _counter, acc) do
+    acc
   end
 
-  defp each_bit(bitstring, _counter, opts) do
+  defp each_bit(bitstring, _counter, acc) do
     size = bit_size(bitstring)
     <<h::size(size)>> = bitstring
-    Inspect.Integer.inspect(h, opts) <> "::size(" <> Integer.to_string(size) <> ")"
+    acc <> Integer.to_string(h) <> "::size(" <> Integer.to_string(size) <> ")"
   end
 
-  @compile {:inline, decrement: 1}
   defp decrement(:infinity), do: :infinity
   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
-    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)
+  def inspect([], _opts), do: "[]"
 
+  def inspect(thing, %Inspect.Opts{char_lists: lists} = opts) do
     cond do
-      lists == :as_charlists or (lists == :infer and printable?(term, printable_limit)) ->
-        inspected =
-          case Inspect.BitString.escape(IO.chardata_to_string(term), ?', printable_limit) do
-            {escaped, ""} -> [?', escaped, ?']
-            {escaped, _} -> [?', escaped, ?', " ++ ..."]
-          end
-        IO.iodata_to_binary inspected
-      keyword?(term) ->
-        surround_many(open, term, close, opts, &keyword/2, sep)
+      lists == :as_char_lists or (lists == :infer and printable?(thing)) ->
+        <<?', Inspect.BitString.escape(IO.chardata_to_string(thing), ?')::binary, ?'>>
+      keyword?(thing) ->
+        surround_many("[", thing, "]", opts, &keyword/2)
       true ->
-        surround_many(open, term, close, opts, &to_doc/2, sep)
+        surround_many("[", thing, "]", opts, &to_doc/2)
     end
   end
 
   @doc false
   def keyword({key, value}, opts) do
-    key = color(key_to_binary(key) <> ": ", :atom, opts)
-    concat(key, to_doc(value, opts))
+    concat(
+      key_to_binary(key) <> ": ",
+      to_doc(value, opts)
+    )
   end
 
   @doc false
   def keyword?([{key, _value} | rest]) when is_atom(key) do
-    case Atom.to_charlist(key) do
+    case Atom.to_char_list(key) do
       'Elixir.' ++ _ -> false
       _ -> keyword?(rest)
     end
@@ -307,25 +305,17 @@ defimpl Inspect, for: List do
   def keyword?(_other), do: false
 
   @doc false
-  def printable?(list), do: printable?(list, :infinity)
-
-  @doc false
-  def printable?(_, 0), do: true
-  def printable?([char | rest], counter) when char in 32..126, do: printable?(rest, decrement(counter))
-  def printable?([?\n | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\r | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\t | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\v | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\b | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\f | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\e | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\a | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([], _counter), do: true
-  def printable?(_, _counter), do: false
-
-  @compile {:inline, decrement: 1}
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
+  def printable?([c|cs]) when is_integer(c) and 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
 
@@ -338,11 +328,10 @@ defimpl Inspect, for: List do
 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)
-    surround_many(open, Tuple.to_list(tuple), close, opts, &to_doc/2, sep)
+    surround_many("{", Tuple.to_list(tuple), "}", opts, &to_doc/2)
   end
 end
 
@@ -353,33 +342,29 @@ defimpl Inspect, for: Map do
 
   def inspect(map, name, opts) do
     map = :maps.to_list(map)
-    open = color("%" <> name <> "{", :map, opts)
-    sep = color(",", :map, opts)
-    close = color("}", :map, opts)
-    surround_many(open, map, close, opts, traverse_fun(map, opts), sep)
+    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
+  defp to_map({key, value}, opts) do
     concat(
-      concat(to_doc(key, opts), sep),
+      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(thing, %Inspect.Opts{base: base}) do
+    Integer.to_string(thing, base_to_value(base))
+    |> prepend_prefix(base)
   end
 
   defp base_to_value(base) do
@@ -403,54 +388,60 @@ defimpl Inspect, for: Integer do
 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(thing, _opts) do
+    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
   end
 end
 
 defimpl Inspect, for: Regex do
-  def inspect(regex, opts) do
-    source = IO.iodata_to_binary(['~r/', escape(regex.source, ?/), ?/, 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(bin, term),
-    do: escape(bin, [], term)
+    do: escape(bin, <<>>, term)
 
-  defp escape(<<term, rest::binary>>, 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?' implementation
+  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::binary>>, buf, term),
-    do: escape(rest, [buf | '\\n'], term)
+  defp escape(<<?\n>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?n>>, term)
 
-  defp escape(<<?\r, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\r'], term)
+  defp escape(<<?\r>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?r>>, term)
 
-  defp escape(<<?\t, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\t'], term)
+  defp escape(<<?\t>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?t>>, term)
 
-  defp escape(<<?\v, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\v'], term)
+  defp escape(<<?\v>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?v>>, term)
 
-  defp escape(<<?\f, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\f'], term)
+  defp escape(<<?\f>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?f>>, term)
 
-  defp escape(<<?\a, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\a'], term)
+  defp escape(<<?\a>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, ?\\, ?a>>, term)
 
-  defp escape(<<char::utf8, rest::binary>>, buf, term)
-       when char in 0x20..0x7E
-       when char in 0xA0..0xD7FF
-       when char in 0xE000..0xFFFD
-       when char in 0x10000..0x10FFFF,
-    do: escape(rest, [buf | <<char::utf8>>], 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(<<char, rest::binary>>, buf, term),
-    do: escape(rest, [buf | Inspect.BitString.escape_char(char)], term)
+  defp escape(<<c>> <> rest, buf, term),
+    do: escape(rest, <<buf::binary, Inspect.BitString.escape_char(c)>>, term)
 
   defp escape(<<>>, buf, _), do: buf
 end
@@ -459,12 +450,11 @@ defimpl Inspect, for: Function do
   def inspect(function, _opts) do
     fun_info = :erlang.fun_info(function)
     mod = fun_info[:module]
-    name = fun_info[:name]
 
     if fun_info[:type] == :external and fun_info[:env] == [] do
-      "&#{Inspect.Atom.inspect(mod)}.#{escape_name(name)}/#{fun_info[:arity]}"
+      "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
     else
-      case Atom.to_charlist(mod) do
+      case Atom.to_char_list(mod) do
         'elixir_compiler_' ++ _ ->
           if function_exported?(mod, :__RELATIVE__, 0) do
             "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
@@ -477,41 +467,6 @@ defimpl Inspect, for: Function do
     end
   end
 
-  def escape_name(atom) when is_atom(atom) do
-    string = Atom.to_string(atom)
-
-    case Macro.classify_identifier(atom) do
-      :callable ->
-        string
-      type when type in [:not_callable, :alias] ->
-        "\"" <> string <> "\""
-      :other ->
-        {escaped, _} = Inspect.BitString.escape(string, ?")
-        IO.iodata_to_binary [?", escaped, ?"]
-    end
-  end
-
-  # Example of this format: -NAME/ARITY-fun-COUNT-
-  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
-    extract_anonymous_fun_parent(Atom.to_string(atom))
-  end
-
-  def extract_anonymous_fun_parent("-" <> rest) do
-    [trailing | reversed] =
-      rest
-      |> String.split("/")
-      |> Enum.reverse()
-
-    case String.split(trailing, "-") do
-      [arity, _inner, _count, ""] ->
-        {reversed |> Enum.reverse |> Enum.join("/") |> String.to_atom(), arity}
-      _other ->
-        :error
-    end
-  end
-
-  def extract_anonymous_fun_parent(other) when is_binary(other), do: :error
-
   defp default_inspect(mod, fun_info) do
     "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in " <>
       "#{Inspect.Atom.inspect(mod)}#{extract_name(fun_info[:name])}>"
@@ -522,11 +477,10 @@ defimpl Inspect, for: Function do
   end
 
   defp extract_name(name) do
-    case extract_anonymous_fun_parent(name) do
-      {name, arity} ->
-        "." <> escape_name(name) <> "/" <> arity
-      :error ->
-        "." <> escape_name(name)
+    name = Atom.to_string(name)
+    case :binary.split(name, "-", [:global]) do
+      ["", name | _] -> "." <> name
+      _ -> "." <> name
     end
   end
 
@@ -544,7 +498,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
 
@@ -565,8 +519,7 @@ defimpl Inspect, for: Any do
       dunder ->
         if :maps.keys(dunder) == :maps.keys(map) do
           pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, map))
-          colorless_opts = %{opts | syntax_colors: []}
-          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, colorless_opts), opts)
+          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, opts), opts)
         else
           Inspect.Map.inspect(map, opts)
         end

lib/elixir/lib/inspect/algebra.ex

@@ -15,72 +15,51 @@ defmodule Inspect.Opts do
       When the default `:infer`, the binary will be printed as a string if it
       is printable, otherwise in bit syntax.
 
-    * `:charlists` - when `:as_charlists` all lists will be printed as char
+    * `:char_lists` - when `:as_char_lists` all lists will be printed as char
       lists, non-printable elements will be escaped.
 
       When `:as_lists` all lists will be printed as lists.
 
-      When the default `:infer`, the list will be printed as a charlist if it
+      When the default `:infer`, the list will be printed as a char list if it
       is printable, otherwise as list.
 
     * `:limit` - limits the number of items that are printed for tuples,
-      bitstrings, maps, lists and any other collection of items. It does not
-      apply to strings nor charlists and defaults to 50.
-
-    * `:printable_limit` - limits the number of bytes that are printed for strings
-      and char lists. Defaults to 4096.
+      bitstrings, and lists, does not apply to strings nor char lists, defaults
+      to 50.
 
     * `:pretty` - if set to `true` enables pretty printing, defaults to `false`.
 
-    * `:width` - defaults to 80 characters, used when pretty is `true` or when
-      printing to IO devices. Set to 0 to force each item to be printed on its
-      own line.
+    * `:width` - defaults to the 80 characters, used when pretty is `true` or
+      when printing to IO devices.
 
-    * `:base` - prints integers as `:binary`, `:octal`, `:decimal`, or `:hex`,
-      defaults to `:decimal`. When inspecting binaries any `:base` other than
-      `:decimal` implies `binaries: :as_binaries`.
+    * `:base` - print integers as :binary, :octal, :decimal, or :hex, defaults
+      to :decimal
 
     * `:safe` - when `false`, failures while inspecting structs will be raised
-      as errors instead of being wrapped in the `Inspect.Error` exception. This
+      as errors instead of being wrapped in the Inspect.Error exception. This
       is useful when debugging failures and crashes for custom inspect
       implementations
 
-    * `:syntax_colors` - when set to a keyword list of colors the output will
-      be colorized. The keys are types and the values are the colors to use for
-      each type. e.g. `[number: :red, atom: :blue]`. Types can include
-      `:number`, `:atom`, `regex`, `:tuple`, `:map`, `:list`, and `:reset`.
-      Colors can be any `t:IO.ANSI.ansidata/0` as accepted by `IO.ANSI.format/1`.
   """
 
-  # TODO: Remove :char_lists key by 2.0
   defstruct structs: true,
             binaries: :infer,
-            charlists: :infer,
             char_lists: :infer,
             limit: 50,
-            printable_limit: 4096,
             width: 80,
             base: :decimal,
             pretty: false,
-            safe: true,
-            syntax_colors: []
+            safe: true
 
-  @type color_key :: atom
-
-  # TODO: Remove :char_lists key and :as_char_lists value by 2.0
   @type t :: %__MODULE__{
                structs: boolean,
                binaries: :infer | :as_binaries | :as_strings,
-               charlists: :infer | :as_lists | :as_charlists,
                char_lists: :infer | :as_lists | :as_char_lists,
                limit: pos_integer | :infinity,
-               printable_limit: pos_integer | :infinity,
                width: pos_integer | :infinity,
                base: :decimal | :binary | :hex | :octal,
                pretty: boolean,
-               safe: boolean,
-               syntax_colors: [{color_key, IO.ANSI.ansidata}]
-             }
+               safe: boolean}
 end
 
 defmodule Inspect.Error do
@@ -98,7 +77,7 @@ defmodule Inspect.Algebra do
   This module implements the functionality described in
   ["Strictly Pretty" (2000) by Christian Lindig][0] with small
   additions, like support for String nodes, and a custom
-  rendering function that maximises horizontal space use.
+  rendering function that maximises horizontal space use. 
 
       iex> Inspect.Algebra.empty
       :doc_nil
@@ -115,7 +94,7 @@ defmodule Inspect.Algebra do
 
   The functions `nest/2`, `space/2` and `line/2` help you put the
   document together into a rigid structure. However, the document
-  algebra gets interesting when using functions like `break/1`, which
+  algebra gets interesting when using functions like `break/2`, which
   converts the given string into a line break depending on how much space
   there is to print. Let's glue two docs together with a break and then
   render it:
@@ -141,7 +120,7 @@ defmodule Inspect.Algebra do
   `:flat` (breaks as spaces) and `:break` (breaks as newlines).
   Implementing the same logic in a strict language such as Elixir leads
   to an exponential growth of possible documents, unless document groups
-  are encoded explicitly as `:flat` or `:break`. Those groups are then reduced
+  are encoded explictly as `:flat` or `:break`. Those groups are then reduced
   to a simple document, where the layout is already decided, per [Lindig][0].
 
   This implementation slightly changes the semantic of Lindig's algorithm
@@ -164,11 +143,11 @@ defmodule Inspect.Algebra do
   @tail_separator " |"
   @newline "\n"
   @nesting 1
-  @space " "
+  @break " "
 
   # Functional interface to "doc" records
 
-  @type t :: :doc_nil | :doc_line | doc_cons | doc_nest | doc_break | doc_group | doc_color | binary
+  @type t :: :doc_nil | :doc_line | doc_cons | doc_nest | doc_break | doc_group | binary
 
   @typep doc_cons :: {:doc_cons, t, t}
   defmacrop doc_cons(left, right) do
@@ -177,7 +156,7 @@ defmodule Inspect.Algebra do
 
   @typep doc_nest :: {:doc_nest, t, non_neg_integer}
   defmacrop doc_nest(doc, indent) do
-    quote do: {:doc_nest, unquote(doc), unquote(indent)}
+    quote do: {:doc_nest, unquote(doc), unquote(indent) }
   end
 
   @typep doc_break :: {:doc_break, binary}
@@ -190,11 +169,6 @@ defmodule Inspect.Algebra do
     quote do: {:doc_group, unquote(group)}
   end
 
-  @typep doc_color :: {:doc_color, t, IO.ANSI.ansidata}
-  defmacrop doc_color(doc, color) do
-    quote do: {:doc_color, unquote(doc), unquote(color)}
-  end
-
   defmacrop is_doc(doc) do
     if Macro.Env.in_guard?(__CALLER__) do
       do_is_doc(doc)
@@ -212,17 +186,15 @@ defmodule Inspect.Algebra do
       is_binary(unquote(doc)) or
       unquote(doc) in [:doc_nil, :doc_line] or
       (is_tuple(unquote(doc)) and
-       elem(unquote(doc), 0) in [:doc_cons, :doc_nest, :doc_break, :doc_group, :doc_color])
+       elem(unquote(doc), 0) in [:doc_cons, :doc_nest, :doc_break, :doc_group])
     end
   end
 
   @doc """
-  Converts an Elixir term to an algebra document
-  according to the `Inspect` protocol.
+  Converts an Elixir structure to an algebra document
+  according to the inspect protocol.
   """
   @spec to_doc(any, Inspect.Opts.t) :: t
-  def to_doc(term, opts)
-
   def to_doc(%{__struct__: struct} = map, %Inspect.Opts{} = opts) when is_atom(struct) do
     if opts.structs do
       try do
@@ -243,7 +215,7 @@ defmodule Inspect.Algebra do
             try do
               Process.put(:inspect_trap, true)
 
-              res = Inspect.Map.inspect(map, %{opts | syntax_colors: []})
+              res = Inspect.Map.inspect(map, opts)
               res = IO.iodata_to_binary(format(res, :infinity))
 
               exception = Inspect.Error.exception(
@@ -282,51 +254,31 @@ defmodule Inspect.Algebra do
   @spec empty() :: :doc_nil
   def empty, do: :doc_nil
 
-  @doc ~S"""
-  Concatenates two document entities returning a new document.
+  @doc """
+  Concatenates two document entities.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.concat("hello", "world")
+      iex> doc = Inspect.Algebra.concat "hello", "world"
       iex> Inspect.Algebra.format(doc, 80)
       ["hello", "world"]
 
   """
-  @spec concat(t, t) :: t
-  def concat(doc1, doc2) when is_doc(doc1) and is_doc(doc2) do
-    doc_cons(doc1, doc2)
+  @spec concat(t, t) :: doc_cons
+  def concat(x, y) when is_doc(x) and is_doc(y) do
+    doc_cons(x, y)
   end
 
-  @doc ~S"""
-  Concatenates a list of documents returning a new document.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.concat(["a", "b", "c"])
-      iex> Inspect.Algebra.format(doc, 80)
-      ["a", "b", "c"]
-
+  @doc """
+  Concatenates a list of documents.
   """
-  @spec concat([t]) :: t
-  def concat(docs) when is_list(docs) do
+  @spec concat([t]) :: doc_cons
+  def concat(docs) do
     fold_doc(docs, &concat(&1, &2))
   end
 
   @doc ~S"""
-  Colors a document if the `color_key` has a color in the options.
-  """
-  @spec color(t, Inspect.Opts.color_key, Inspect.Opts.t) :: doc_color
-  def color(doc, color_key, %Inspect.Opts{syntax_colors: syntax_colors}) when is_doc(doc) do
-    if precolor = Keyword.get(syntax_colors, color_key) do
-      postcolor = Keyword.get(syntax_colors, :reset, :reset)
-      concat(doc_color(doc, precolor), doc_color(empty(), postcolor))
-    else
-      doc
-    end
-  end
-
-  @doc ~S"""
-  Nests the given document at the given `level`.
+  Nests document entity `x` positions deep.
 
   Nesting will be appended to the line breaks.
 
@@ -338,91 +290,58 @@ defmodule Inspect.Algebra do
 
   """
   @spec nest(t, non_neg_integer) :: doc_nest
-  def nest(doc, level)
-
-  def nest(doc, 0) when is_doc(doc) do
-    doc
+  def nest(x, 0) when is_doc(x) do
+    x
   end
 
-  def nest(doc, level) when is_doc(doc) and is_integer(level) and level > 0 do
-    doc_nest(doc, level)
+  def nest(x, i) when is_doc(x) and is_integer(i) do
+    doc_nest(x, i)
   end
 
   @doc ~S"""
-  Returns a document entity representing a break based on the given
-  `string`.
+  Document entity representing a break.
 
-  This break can be rendered as a linebreak or as the given `string`,
+  This break can be rendered as a linebreak or as spaces,
   depending on the `mode` of the chosen layout or the provided
   separator.
 
   ## Examples
 
-  Let's create a document by concatenating two strings with a break between
-  them:
+  Let's glue two docs together with a break and then render it:
 
-      iex> doc = Inspect.Algebra.concat(["a", Inspect.Algebra.break("\t"), "b"])
+      iex> doc = Inspect.Algebra.glue("a", " ", "b")
       iex> Inspect.Algebra.format(doc, 80)
-      ["a", "\t", "b"]
+      ["a", " ", "b"]
 
-  Notice the break was represented with the given string, because we didn't
-  reach a line limit. Once we do, it is replaced by a newline:
+  Notice the break was represented as is, because we haven't reached
+  a line limit. Once we do, it is replaced by a newline:
 
-      iex> break = Inspect.Algebra.break("\t")
-      iex> doc = Inspect.Algebra.concat([String.duplicate("a", 20), break, "b"])
+      iex> doc = Inspect.Algebra.glue(String.duplicate("a", 20), " ", "b")
       iex> Inspect.Algebra.format(doc, 10)
       ["aaaaaaaaaaaaaaaaaaaa", "\n", "b"]
 
   """
   @spec break(binary) :: doc_break
-  def break(string) when is_binary(string), do: doc_break(string)
+  def break(s) when is_binary(s), do: doc_break(s)
 
-  @doc ~S"""
-  Returns a document entity with the `" "` string as break.
-
-  See `break/1` for more information.
-  """
   @spec break() :: doc_break
-  def break(), do: doc_break(@space)
-
-  @doc ~S"""
-  Glues two documents together inserting `" "` as a break between them.
-
-  This means the two documents will be separated by `" "` in case they
-  fit in the same line. Otherwise a line break is used.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", "world")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["hello", " ", "world"]
+  def break(), do: doc_break(@break)
 
+  @doc """
+  Inserts a break between two docs. See `break/1` for more info.
   """
-  @spec glue(t, t) :: t
-  def glue(doc1, doc2), do: concat(doc1, concat(break(), doc2))
-
-  @doc ~S"""
-  Glues two documents (`doc1` and `doc2`) together inserting the given
-  break `break_string` between them.
-
-  For more information on how the break is inserted, see `break/1`.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", "\t", "world")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["hello", "\t", "world"]
+  @spec glue(t, t) :: doc_cons
+  def glue(x, y), do: concat(x, concat(break, y))
 
+  @doc """
+  Inserts a break, passed as the second argument, between two docs,
+  the first and the third arguments.
   """
-  @spec glue(t, binary, t) :: t
-  def glue(doc1, break_string, doc2) when is_binary(break_string),
-    do: concat(doc1, concat(break(break_string), doc2))
+  @spec glue(t, binary, t) :: doc_cons
+  def glue(x, g, y) when is_binary(g), do: concat(x, concat(break(g), y))
 
   @doc ~S"""
-  Returns a group containing the specified document `doc`.
-
-  Documents in a group are attempted to be rendered together
-  to the best of the renderer ability.
+  Returns a group containing the specified document.
 
   ## Examples
 
@@ -449,91 +368,83 @@ defmodule Inspect.Algebra do
 
   """
   @spec group(t) :: doc_group
-  def group(doc) when is_doc(doc) do
-    doc_group(doc)
+  def group(d) when is_doc(d) do
+    doc_group(d)
   end
 
-  @doc ~S"""
-  Inserts a mandatory single space between two documents.
+  @doc """
+  Inserts a mandatory single space between two document entities.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.space("Hughes", "Wadler")
-      iex> Inspect.Algebra.format(doc, 5)
+      iex> doc = Inspect.Algebra.space "Hughes", "Wadler"
+      iex> Inspect.Algebra.format(doc, 80)
       ["Hughes", " ", "Wadler"]
 
   """
-  @spec space(t, t) :: t
-  def space(doc1, doc2), do: concat(doc1, concat(" ", doc2))
+  @spec space(t, t) :: doc_cons
+  def space(x, y), do: concat(x, concat(" ", y))
 
   @doc ~S"""
-  Inserts a mandatory linebreak between two documents.
+  Inserts a mandatory linebreak between two document entities.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.line("Hughes", "Wadler")
+      iex> doc = Inspect.Algebra.line "Hughes", "Wadler"
       iex> Inspect.Algebra.format(doc, 80)
       ["Hughes", "\n", "Wadler"]
 
   """
-  @spec line(t, t) :: t
-  def line(doc1, doc2), do: concat(doc1, concat(:doc_line, doc2))
+  @spec line(t, t) :: doc_cons
+  def line(x, y), do: concat(x, concat(:doc_line, y))
 
-  @doc ~S"""
-  Folds a list of documents into a document using the given folder function.
-
-  The list of documents is folded "from the right"; in that, this function is
-  similar to `List.foldr/3`, except that it doesn't expect an initial
-  accumulator and uses the last element of `docs` as the initial accumulator.
+  @doc """
+  Folds a list of document entities into a document entity
+  using a function that is passed as the first argument.
 
   ## Examples
 
-      iex> docs = ["A", "B", "C"]
-      iex> docs = Inspect.Algebra.fold_doc(docs, fn(doc, acc) ->
-      ...>   Inspect.Algebra.concat([doc, "!", acc])
+      iex> doc = ["A", "B"]
+      iex> doc = Inspect.Algebra.fold_doc(doc, fn(x, y) ->
+      ...>   Inspect.Algebra.concat [x, "!", y]
       ...> end)
-      iex> Inspect.Algebra.format(docs, 80)
-      ["A", "!", "B", "!", "C"]
+      iex> Inspect.Algebra.format(doc, 80)
+      ["A", "!", "B"]
 
   """
   @spec fold_doc([t], ((t, t) -> t)) :: t
-  def fold_doc(docs, folder_fun)
-
-  def fold_doc([], _folder_fun),
-    do: empty()
-  def fold_doc([doc], _folder_fun),
-    do: doc
-  def fold_doc([doc | docs], folder_fun) when is_function(folder_fun, 2),
-    do: folder_fun.(doc, fold_doc(docs, folder_fun))
+  def fold_doc(list, fun)
+  def fold_doc([], _), do: empty
+  def fold_doc([doc], _), do: doc
+  def fold_doc([d|ds], fun), do: fun.(d, fold_doc(ds, fun))
 
   # Elixir conveniences
 
   @doc ~S"""
   Surrounds a document with characters.
 
-  Puts the given document `doc` between the `left` and `right` documents enclosing
-  and nesting it. The document is marked as a group, to show the maximum as
-  possible concisely together.
+  Puts the document between left and right enclosing and nesting it.
+  The document is marked as a group, to show the maximum as possible
+  concisely together.
 
   ## Examples
 
-      iex> doc = Inspect.Algebra.surround("[", Inspect.Algebra.glue("a", "b"), "]")
+      iex> doc = Inspect.Algebra.surround "[", Inspect.Algebra.glue("a", "b"), "]"
       iex> Inspect.Algebra.format(doc, 3)
       ["[", "a", "\n ", "b", "]"]
 
   """
-  @spec surround(t, t, t) :: t
-  def surround(left, doc, right) when is_doc(left) and is_doc(doc) and is_doc(right) do
-    group(concat(left, concat(nest(doc, @nesting), right)))
+  @spec surround(binary, t, binary) :: t
+  def surround(left, doc, right) do
+    group concat left, concat(nest(doc, @nesting), right)
   end
 
   @doc ~S"""
   Maps and glues a collection of items.
 
-  It uses the given `left` and `right` documents as surrounding and the
-  separator document `separator` to separate items in `docs`. A limit can be
-  passed: when this limit is reached, this function stops gluing and outputs
-  `"..."` instead.
+  It uses the given left and right as surrounding and a separator for
+  each item. A limit can be passed which, once reached, stops gluing
+  and outputs "..." instead.
 
   ## Examples
 
@@ -551,11 +462,9 @@ defmodule Inspect.Algebra do
       ...>         %Inspect.Opts{limit: 3}, fn i, _opts -> to_string(i) end, "!")
       iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary
       "[1! 2! 3! ...]"
-
   """
-  @spec surround_many(t, [any], t, Inspect.Opts.t, (term, Inspect.Opts.t -> t), t) :: t
-  def surround_many(left, docs, right, %Inspect.Opts{} = opts, fun, separator \\ @surround_separator)
-      when is_doc(left) and is_list(docs) and is_doc(right) and is_function(fun, 2) and is_doc(separator) do
+  @spec surround_many(binary, [any], binary, Inspect.Opts.t, (term, Inspect.Opts.t -> t), binary) :: t
+  def surround_many(left, docs, right, opts, fun, separator \\ @surround_separator) do
     do_surround_many(left, docs, right, opts.limit, opts, fun, separator)
   end
 
@@ -579,14 +488,14 @@ defmodule Inspect.Algebra do
     fun.(h, %{opts | limit: limit})
   end
 
-  defp do_surround_many([h | t], limit, opts, fun, sep) when is_list(t) do
+  defp do_surround_many([h|t], limit, opts, fun, sep) when is_list(t) do
     limit = decrement(limit)
     h = fun.(h, %{opts | limit: limit})
     t = do_surround_many(t, limit, opts, fun, sep)
     do_join(h, t, sep)
   end
 
-  defp do_surround_many([h | t], limit, opts, fun, _sep) do
+  defp do_surround_many([h|t], limit, opts, fun, _sep) do
     limit = decrement(limit)
     h = fun.(h, %{opts | limit: limit})
     t = fun.(t, %{opts | limit: limit})
@@ -601,25 +510,16 @@ defmodule Inspect.Algebra do
   defp decrement(:infinity), do: :infinity
   defp decrement(counter),   do: counter - 1
 
-  @doc ~S"""
-  Formats a given document for a given width.
+  @doc """
+  The formatting function.
 
   Takes the maximum width and a document to print as its arguments
   and returns an IO data representation of the best layout for the
   document to fit in the given width.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", " ", "world")
-      iex> Inspect.Algebra.format(doc, 30) |> IO.iodata_to_binary()
-      "hello world"
-      iex> Inspect.Algebra.format(doc, 10) |> IO.iodata_to_binary()
-      "hello\nworld"
-
   """
   @spec format(t, non_neg_integer | :infinity) :: iodata
-  def format(doc, width) when is_doc(doc) and (width == :infinity or width >= 0) do
-    format(width, 0, [{0, default_mode(width), doc_group(doc)}])
+  def format(d, w) do
+    format(w, 0, [{0, default_mode(w), doc_group(d)}])
   end
 
   defp default_mode(:infinity), do: :flat
@@ -634,11 +534,10 @@ defmodule Inspect.Algebra do
   defp fits?(_, [{_, _, :doc_line} | _]),           do: true
   defp fits?(w, [{_, _, :doc_nil} | t]),            do: fits?(w, t)
   defp fits?(w, [{i, m, doc_cons(x, y)} | t]),      do: fits?(w, [{i, m, x} | [{i, m, y} | t]])
-  defp fits?(w, [{i, m, doc_color(x, _)} | t]),    do: fits?(w, [{i, m, x} | t])
   defp fits?(w, [{i, m, doc_nest(x, j)} | t]),      do: fits?(w, [{i + j, m, x} | t])
   defp fits?(w, [{i, _, doc_group(x)} | t]),        do: fits?(w, [{i, :flat, x} | t])
-  defp fits?(w, [{_, _, s} | t]) when is_binary(s), do: fits?((w - byte_size(s)), t)
-  defp fits?(w, [{_, :flat, doc_break(s)} | t]),    do: fits?((w - byte_size(s)), t)
+  defp fits?(w, [{_, _, s} | t]) when is_binary(s), do: fits?((w - byte_size s), t)
+  defp fits?(w, [{_, :flat, doc_break(s)} | t]),    do: fits?((w - byte_size s), t)
   defp fits?(_, [{_, :break, doc_break(_)} | _]),   do: true
 
   @spec format(integer | :infinity, integer, [{integer, mode, t}]) :: [binary]
@@ -648,9 +547,8 @@ defmodule Inspect.Algebra do
   defp format(w, k, [{i, m, doc_cons(x, y)} | t]),      do: format(w, k, [{i, m, x} | [{i, m, y} | t]])
   defp format(w, k, [{i, m, doc_nest(x, j)} | t]),      do: format(w, k, [{i + j, m, x} | t])
   defp format(w, k, [{i, m, doc_group(x)} | t]),        do: format(w, k, [{i, m, x} | t])
-  defp format(w, k, [{i, m, doc_color(x, c)} | t]),     do: [ansi(c) | format(w, k, [{i, m, x} | t])]
-  defp format(w, k, [{_, _, s} | t]) when is_binary(s), do: [s | format(w, (k + byte_size(s)), t)]
-  defp format(w, k, [{_, :flat, doc_break(s)} | t]),    do: [s | format(w, (k + byte_size(s)), t)]
+  defp format(w, k, [{_, _, s} | t]) when is_binary(s), do: [s | format(w, (k + byte_size s), t)]
+  defp format(w, k, [{_, :flat, doc_break(s)} | t]),    do: [s | format(w, (k + byte_size s), t)]
   defp format(w, k, [{i, :break, doc_break(s)} | t]) do
     k = k + byte_size(s)
 
@@ -661,10 +559,6 @@ defmodule Inspect.Algebra do
     end
   end
 
-  defp ansi(color) do
-    IO.ANSI.format_fragment(color, true)
-  end
-
   defp indent(0), do: @newline
   defp indent(i), do: @newline <> :binary.copy(" ", i)
 end

lib/elixir/lib/integer.ex

@@ -6,37 +6,28 @@ defmodule Integer do
   import Bitwise
 
   @doc """
-  Determines if `integer` is odd.
+  Determines if an integer is odd.
 
-  Returns `true` if the given `integer` is an odd number,
-  otherwise it returns `false`.
+  Returns `true` if `n` is an odd number, otherwise `false`.
 
   Allowed in guard clauses.
 
   ## Examples
 
-      iex> Integer.is_odd(5)
+      iex> Integer.is_odd(3)
       true
 
-      iex> Integer.is_odd(6)
+      iex> Integer.is_odd(4)
       false
-
-      iex> Integer.is_odd(-5)
-      true
-
-      iex> Integer.is_odd(0)
-      false
-
   """
-  defmacro is_odd(integer) do
-    quote do: (unquote(integer) &&& 1) == 1
+  defmacro is_odd(n) do
+    quote do: (unquote(n) &&& 1) == 1
   end
 
   @doc """
-  Determines if an `integer` is even.
+  Determines if an integer is even.
 
-  Returns `true` if the given `integer` is an even number,
-  otherwise it returns `false`.
+  Returns `true` if `n` is an even number, otherwise `false`.
 
   Allowed in guard clauses.
 
@@ -47,164 +38,72 @@ defmodule Integer do
 
       iex> Integer.is_even(5)
       false
-
-      iex> Integer.is_even(-10)
-      true
-
-      iex> Integer.is_even(0)
-      true
-
   """
-  defmacro is_even(integer) do
-    quote do: (unquote(integer) &&& 1) == 0
+  defmacro is_even(n) do
+    quote do: (unquote(n) &&& 1) == 0
   end
 
   @doc """
-  Computes the modulo remainder of an integer division.
+  Returns the ordered digits for the given non-negative integer.
 
-  `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`.
+  An optional base value may be provided representing the radix for the returned
+  digits.
 
   ## Examples
 
-      iex> Integer.mod(5, 2)
-      1
-      iex> Integer.mod(6, -4)
-      -2
+      iex> Integer.digits(101)
+      [1, 0, 1]
+
+      iex> Integer.digits(58127, 2)
+      [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]
 
   """
-  @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
+  @spec digits(non_neg_integer, pos_integer) :: [non_neg_integer]
+  def digits(n, base \\ 10) when is_integer(n)    and n >= 0
+                            and  is_integer(base) and base >= 2 do
+    do_digits(n, base, [])
+  end
+
+  defp do_digits(0, _base, []),  do: [0]
+  defp do_digits(0, _base, acc), do: acc
+  defp do_digits(n, base, acc)  do
+    do_digits div(n, base), base, [rem(n, base) | acc]
   end
 
   @doc """
-  Performs a floored integer division.
+  Returns the integer represented by the ordered digits.
 
-  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.
+  An optional base value may be provided representing the radix for the digits.
 
   ## Examples
 
-      iex> Integer.floor_div(5, 2)
-      2
-      iex> Integer.floor_div(6, -4)
-      -2
-      iex> Integer.floor_div(-99, 2)
-      -50
-
-  """
-  @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`.
-
-  An optional `base` value may be provided representing the radix for the returned
-  digits. This one must be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.digits(123)
-      [1, 2, 3]
-
-      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, ...]
-  def digits(integer, base \\ 10)
-      when is_integer(integer) and is_integer(base) and base >= 2 do
-    do_digits(integer, base, [])
-  end
-
-  defp do_digits(digit, base, []) when abs(digit) < base,
-    do: [digit]
-  defp do_digits(digit, base, []) when digit == -base,
-    do: [-1, 0]
-  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])
-
-  @doc """
-  Returns the integer represented by the ordered `digits`.
-
-  An optional `base` value may be provided representing the radix for the `digits`.
-  This one can be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.undigits([1, 2, 3])
-      123
+      iex> Integer.undigits([1, 0, 1])
+      101
 
       iex> Integer.undigits([1, 4], 16)
       20
-
-      iex> Integer.undigits([])
-      0
-
   """
   @spec undigits([integer], integer) :: integer
-  def undigits(digits, base \\ 10) when is_list(digits) and is_integer(base) and base >= 2 do
+  def undigits(digits, base \\ 10) when is_integer(base) do
     do_undigits(digits, base, 0)
   end
 
-  defp do_undigits([], _base, 0),
-    do: 0
-  defp do_undigits([digit], base, 0) when is_integer(digit) and digit < base,
-    do: digit
-  defp do_undigits([1, 0], base, 0),
-    do: base
-  defp do_undigits([0 | tail], base, 0),
-    do: do_undigits(tail, base, 0)
-
-  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([], _base, acc), do: acc
+  defp do_undigits([digit | tail], base, acc) do
+    do_undigits(tail, base, acc * base + digit)
+  end
 
   @doc """
-  Parses a text representation of an integer.
+  Converts a binary from a text representation of an integer
+  in an optional base `base` to the corresponding integer.
 
-  An optional `base` to the corresponding integer can be provided.
-  If `base` is not given, 10 will be used.
+  If the base `base` is not given, base 10 will be used.
 
-  If successful, returns a tuple in the form of `{integer, remainder_of_binary}`.
+  If successful, returns a tuple of the form `{integer, remainder_of_binary}`.
   Otherwise `:error`.
 
   Raises an error if `base` is less than 2 or more than 36.
 
-  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
 
       iex> Integer.parse("34")
@@ -232,50 +131,73 @@ 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 not base in 2..36 do
-    raise ArgumentError, "invalid base #{inspect base}"
+  def parse(binary, base) when is_integer(base) 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
-      count ->
-        {digits, rem} = :erlang.split_binary(binary, count)
-        {:erlang.binary_to_integer(digits, base), rem}
+  def parse(_, base) do
+    raise ArgumentError, "invalid base #{base}"
+  end
+
+  defp parse_in_base("-" <> bin, base) do
+    case do_parse(bin, base) do
+      :error -> :error
+      {number, remainder} -> {-number, remainder}
     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(bin, base) when is_binary(bin) do
+    do_parse(bin, 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)
-  end
+  defp do_parse(_, _), do: :error
 
-  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
-  of `integer`.
+  of `some_integer`.
 
   Inlined by the compiler.
 
@@ -284,26 +206,15 @@ defmodule Integer do
       iex> Integer.to_string(123)
       "123"
 
-      iex> Integer.to_string(+456)
-      "456"
-
-      iex> Integer.to_string(-789)
-      "-789"
-
-      iex> Integer.to_string(0123)
-      "123"
-
   """
   @spec to_string(integer) :: String.t
-  def to_string(integer) do
-    :erlang.integer_to_binary(integer)
+  def to_string(some_integer) do
+    :erlang.integer_to_binary(some_integer)
   end
 
   @doc """
   Returns a binary which corresponds to the text representation
-  of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36.
+  of `some_integer` in base `base`.
 
   Inlined by the compiler.
 
@@ -312,115 +223,42 @@ defmodule Integer do
       iex> Integer.to_string(100, 16)
       "64"
 
-      iex> Integer.to_string(-100, 16)
-      "-64"
-
-      iex> Integer.to_string(882681651, 36)
-      "ELIXIR"
-
   """
   @spec to_string(integer, 2..36) :: String.t
-  def to_string(integer, base) do
-    :erlang.integer_to_binary(integer, base)
+  def to_string(some_integer, base) do
+    :erlang.integer_to_binary(some_integer, base)
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation of the given `integer`.
+  Returns a char list which corresponds to the text representation of the given integer.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Integer.to_charlist(123)
-      '123'
-
-      iex> Integer.to_charlist(+456)
-      '456'
-
-      iex> Integer.to_charlist(-789)
-      '-789'
-
-      iex> Integer.to_charlist(0123)
-      '123'
+      iex> Integer.to_char_list(7)
+      '7'
 
   """
-  @spec to_charlist(integer) :: charlist
-  def to_charlist(integer) do
-    :erlang.integer_to_list(integer)
+  @spec to_char_list(integer) :: char_list
+  def to_char_list(number) do
+    :erlang.integer_to_list(number)
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation of `integer` in the given `base`.
-
-  `base` can be an integer between 2 and 36.
+  Returns a char list which corresponds to the text representation of the
+  given integer in the given base.
 
   Inlined by the compiler.
 
   ## Examples
 
-      iex> Integer.to_charlist(100, 16)
-      '64'
-
-      iex> Integer.to_charlist(-100, 16)
-      '-64'
-
-      iex> Integer.to_charlist(882681651, 36)
-      'ELIXIR'
+      iex> Integer.to_char_list(1023, 16)
+      '3FF'
 
   """
-  @spec to_charlist(integer, 2..36) :: charlist
-  def to_charlist(integer, base) do
-    :erlang.integer_to_list(integer, base)
+  @spec to_char_list(integer, 2..36) :: char_list
+  def to_char_list(number, base) do
+    :erlang.integer_to_list(number, 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
-
-  """
-  @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
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(integer) :: charlist
-  def to_char_list(integer), do: Integer.to_charlist(integer)
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(integer, 2..36) :: charlist
-  def to_char_list(integer, base), do: Integer.to_charlist(integer, base)
 end

lib/elixir/lib/io.ex

@@ -1,25 +1,25 @@
 defmodule IO do
   @moduledoc """
-  Functions handling input/output (IO).
+  Functions handling 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`.
 
-  The majority of the functions expect chardata, i.e. strings or
+  The majority of the functions expect char data, i.e. strings or
   lists of characters and strings. In case another type is given,
   functions will convert to string via the `String.Chars` protocol
   (as shown in typespecs).
 
-  The functions starting with `bin` expect iodata as an argument,
+  The functions starting with `bin*` expect iodata as an argument,
   i.e. binaries or lists of bytes and binaries.
 
   ## 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:
+  Elixir provides two shorcuts:
 
     * `:stdio` - a shortcut for `:standard_io`, which maps to
       the current `Process.group_leader/0` in Erlang
@@ -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))
@@ -45,15 +47,12 @@ defmodule IO do
   end
 
   @doc """
-  Reads from the IO `device`.
-
-  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.
+  Reads `count` characters from the IO device, a whole
+  `:line` or the whole device with `:all`.
 
   It returns:
 
-    * `data` - the output characters
+    * `data` - the input characters
 
     * `:eof` - end of file was encountered
 
@@ -65,7 +64,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, chars_or_line)
 
   def read(device, :all) do
     do_read_all(map_dev(device), "")
@@ -75,7 +74,7 @@ defmodule IO do
     :io.get_line(map_dev(device), '')
   end
 
-  def read(device, count) when is_integer(count) and count >= 0 do
+  def read(device, count) when count >= 0 do
     :io.get_chars(map_dev(device), '', count)
   end
 
@@ -88,15 +87,12 @@ defmodule IO do
   end
 
   @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
-  `:line` is given.
-  Alternatively, if `:all` is given, then whole `device` is returned.
+  Reads `count` characters from the IO device, a whole
+  `:line` or the whole device with `:all`.
 
   It returns:
 
-    * `data` - the output bytes
+    * `data` - the input characters
 
     * `:eof` - end of file was encountered
 
@@ -107,11 +103,11 @@ defmodule IO do
   If `:all` is given, `:eof` is never returned, but an
   empty string in case the device has reached EOF.
 
-  Note: do not use this function on IO devices in Unicode mode
+  Note: do not use this function on IO devices in unicode mode
   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, chars_or_line)
 
   def binread(device, :all) do
     do_binread_all(map_dev(device), "")
@@ -124,7 +120,7 @@ defmodule IO do
     end
   end
 
-  def binread(device, count) when is_integer(count) and count >= 0 do
+  def binread(device, count) when count >= 0 do
     case :file.read(map_dev(device), count) do
       {:ok, data} -> data
       other -> other
@@ -141,189 +137,87 @@ defmodule IO do
   end
 
   @doc """
-  Writes `item` to the given `device`.
+  Writes the given argument 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
 
       IO.write "sample"
-      #=> sample
+      #=> "sample"
 
       IO.write :stderr, "error"
-      #=> error
+      #=> "error"
 
   """
   @spec write(device, chardata | String.Chars.t) :: :ok
-  def write(device \\ :stdio, item) do
+  def write(device \\ group_leader(), item) do
     :io.put_chars map_dev(device), to_chardata(item)
   end
 
   @doc """
-  Writes `item` as a binary to the given `device`.
-  No Unicode conversion happens.
-  The operation is Unicode unsafe.
+  Writes the given argument to the given device
+  as a binary, no unicode conversion happens.
 
   Check `write/2` for more information.
 
-  Note: do not use this function on IO devices in Unicode mode
+  Note: do not use this function on IO devices in unicode mode
   as it will return the wrong result.
   """
   @spec binwrite(device, iodata) :: :ok | {:error, term}
-  def binwrite(device \\ :stdio, item) when is_iodata(item) do
+  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.
+  Writes the argument to the device, similar to `write/2`,
+  but adds a newline at the end. The argument is expected
+  to be a chardata.
   """
   @spec puts(device, chardata | String.Chars.t) :: :ok
-  def puts(device \\ :stdio, item) do
-    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
+  def puts(device \\ group_leader(), item) do
+    erl_dev = map_dev(device)
+    :io.put_chars erl_dev, [to_chardata(item), ?\n]
   end
 
   @doc """
-  Writes a `message` to stderr, along with the given `stacktrace`.
-
-  This function also notifies the compiler a warning was printed
-  (in case --warnings-as-errors was enabled). It returns `:ok`
-  if it succeeds.
-
-  An empty list can be passed to avoid stacktrace printing.
-
-  ## Examples
-
-      stacktrace = [{MyApp, :main, 1, [file: 'my_app.ex', line: 4]}]
-      IO.warn "variable bar is unused", stacktrace
-      #=> warning: variable bar is unused
-      #=>   my_app.ex:4: MyApp.main/1
-
-  """
-  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
-  def warn(message, []) do
-    :elixir_errors.warn([to_chardata(message), ?\n])
-  end
-  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 """
-  Writes a `message` to stderr, along with the current stacktrace.
-
-  It returns `:ok` if it succeeds.
-
-  ## Examples
-
-      IO.warn "variable bar is unused"
-      #=> warning: variable bar is unused
-      #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
-
-  """
-  @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))
-  end
-
-  @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.
+  Inspects and writes the given argument to the device.
 
   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`.
+  Inspects the item with options using the given 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)
-    chardata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), 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
 
   @doc """
-  Gets a number of bytes from IO device `:stdio`.
-
-  If `:stdio` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
+  Gets a number of bytes from the io device. If the
+  io device is a unicode device, `count` implies
+  the number of unicode codepoints to be retrieved.
   Otherwise, `count` is the number of raw bytes to be retrieved.
-
-  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
-  def getn(prompt, count \\ 1)
-
-  def getn(prompt, count) when is_integer(count) and count > 0 do
-    getn(:stdio, prompt, count)
-  end
-
-  def getn(device, prompt) when not is_integer(prompt) do
-    getn(device, prompt, 1)
-  end
-
-  @doc """
-  Gets a number of bytes from the IO `device`.
-
-  If the IO `device` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
-  Otherwise, `count` is the number of raw bytes to be retrieved.
-
   It returns:
 
     * `data` - the input characters
@@ -333,15 +227,32 @@ defmodule IO do
     * `{:error, reason}` - other (rare) error condition;
       for instance, `{:error, :estale}` if reading from an
       NFS volume
+  """
+  @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) do
+    getn(group_leader, prompt, count)
+  end
+
+  def getn(device, prompt) do
+    getn(device, prompt, 1)
+  end
+
+  @doc """
+  Gets a number of bytes from the io device. If the
+  io device is a unicode device, `count` implies
+  the number of unicode codepoints to be retrieved.
+  Otherwise, `count` is the number of raw bytes to be retrieved.
   """
   @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  def getn(device, prompt, count) when is_integer(count) and count > 0 do
+  def getn(device, prompt, count) do
     :io.get_chars(map_dev(device), to_chardata(prompt), count)
   end
 
-  @doc ~S"""
-  Reads a line from the IO `device`.
+  @doc """
+  Reads a line from the IO device.
 
   It returns:
 
@@ -358,25 +269,24 @@ defmodule IO do
 
   To display "What is your name?" as a prompt and await user input:
 
-      IO.gets "What is your name?\n"
-
+      IO.gets "What is your name?"
   """
   @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
-  def gets(device \\ :stdio, prompt) do
+  def gets(device \\ group_leader(), prompt) do
     :io.get_line(map_dev(device), to_chardata(prompt))
   end
 
   @doc """
-  Converts the IO `device` into an `IO.Stream`.
+  Converts the io device into a `IO.Stream`.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The `device` is iterated by the given number of characters or line by line if
-  `:line` is given.
+  The device is iterated line by line if `:line` is given or
+  by a given number of codepoints.
 
-  This reads from the IO as UTF-8. Check out
+  This reads 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
@@ -391,34 +301,28 @@ defmodule IO do
 
   """
   @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
+  def stream(device, line_or_codepoints) do
     IO.Stream.__build__(map_dev(device), false, line_or_codepoints)
   end
 
   @doc """
-  Converts the IO `device` into an `IO.Stream`. The operation is Unicode unsafe.
+  Converts the IO device into a `IO.Stream`.
 
   An `IO.Stream` implements both `Enumerable` and
   `Collectable`, allowing it to be used for both read
   and write.
 
-  The `device` is iterated by the given number of bytes or line by line if
-  `:line` is given.
-  This reads from the IO device as a raw binary.
+  The device is iterated line by line or by a number of bytes.
+  This reads the IO device as a raw binary.
 
   Note that an IO stream has side effects and every time
   you go over the stream you may get different results.
 
-  Finally, do not use this function on IO devices in Unicode
+  Finally, do not use this function on IO devices in unicode
   mode as it will return the wrong result.
-
   """
   @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
+  def binstream(device, line_or_bytes) do
     IO.Stream.__build__(map_dev(device), true, line_or_bytes)
   end
 
@@ -426,8 +330,8 @@ defmodule IO do
   Converts chardata (a list of integers representing codepoints,
   lists and strings) into a string.
 
-  In case the conversion fails, it raises an `UnicodeConversionError`.
-  If a string is given, it returns the string itself.
+  In case the conversion fails, it raises a `UnicodeConversionError`.
+  If a string is given, returns the string itself.
 
   ## Examples
 
@@ -437,9 +341,6 @@ defmodule IO do
       iex> IO.chardata_to_string([0x0061, "bc"])
       "abc"
 
-      iex> IO.chardata_to_string("string")
-      "string"
-
   """
   @spec chardata_to_string(chardata) :: String.t | no_return
   def chardata_to_string(string) when is_binary(string) do
@@ -447,17 +348,25 @@ defmodule IO do
   end
 
   def chardata_to_string(list) when is_list(list) do
-    List.to_string(list)
+    case :unicode.characters_to_binary(list) do
+      result when is_binary(result) ->
+        result
+
+      {:error, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
+
+      {:incomplete, encoded, rest} ->
+        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
+    end
   end
 
   @doc """
   Converts iodata (a list of integers representing bytes, lists
   and binaries) into a binary.
-  The operation is Unicode unsafe.
 
   Notice that this function treats lists of integers as raw bytes
   and does not perform any kind of encoding conversion. If you want
-  to convert from a charlist to a string (UTF-8 encoded), please
+  to convert from a char list to a string (UTF-8 encoded), please
   use `chardata_to_string/1` instead.
 
   If this function receives a binary, the same binary is returned.
@@ -469,7 +378,7 @@ defmodule IO do
       iex> bin1 = <<1, 2, 3>>
       iex> bin2 = <<4, 5>>
       iex> bin3 = <<6>>
-      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4 | bin3])
+      iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4|bin3])
       <<1, 2, 3, 1, 2, 3, 4, 5, 4, 6>>
 
       iex> bin = <<1, 2, 3>>
@@ -489,7 +398,7 @@ defmodule IO do
 
   ## Examples
 
-      iex> IO.iodata_length([1, 2 | <<3, 4>>])
+      iex> IO.iodata_length([1, 2|<<3, 4>>])
       4
 
   """
@@ -499,8 +408,8 @@ defmodule IO do
   end
 
   @doc false
-  def each_stream(device, line_or_codepoints) do
-    case read(device, line_or_codepoints) do
+  def each_stream(device, what) do
+    case read(device, what) do
       :eof ->
         {:halt, device}
       {:error, reason} ->
@@ -511,8 +420,8 @@ defmodule IO do
   end
 
   @doc false
-  def each_binstream(device, line_or_chars) do
-    case binread(device, line_or_chars) do
+  def each_binstream(device, what) do
+    case binread(device, what) do
       :eof ->
         {:halt, device}
       {:error, reason} ->
@@ -524,7 +433,7 @@ defmodule IO do
 
   @compile {:inline, map_dev: 1, to_chardata: 1}
 
-  # Map the Elixir names for standard IO and error to Erlang names
+  # Map the Elixir names for standard io and error to Erlang names
   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,9 +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.
@@ -42,7 +42,7 @@ defmodule IO.ANSI do
     Application.get_env(:elixir, :ansi_enabled, false)
   end
 
-  @doc "Sets foreground color."
+  @doc "Sets foreground color"
   @spec color(0..255) :: String.t
   def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
 
@@ -56,7 +56,7 @@ defmodule IO.ANSI do
     color(16 + (36 * r) + (6 * g) + b)
   end
 
-  @doc "Sets background color."
+  @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"
 
@@ -70,109 +70,97 @@ defmodule IO.ANSI do
     color_background(16 + (36 * r) + (6 * g) + b)
   end
 
-  @doc "Resets all attributes."
+  @doc "Resets all attributes"
   defsequence :reset, 0
 
-  @doc "Bright (increased intensity) or bold."
+  @doc "Bright (increased intensity) or Bold"
   defsequence :bright, 1
 
-  @doc "Faint (decreased intensity). Not widely supported."
+  @doc "Faint (decreased intensity), not widely supported"
   defsequence :faint, 2
 
-  @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
+  @doc "Italic: on. Not widely supported. Sometimes treated as inverse"
   defsequence :italic, 3
 
-  @doc "Underline: single."
+  @doc "Underline: Single"
   defsequence :underline, 4
 
-  @doc "Blink: slow. Less than 150 per minute."
+  @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."
+  @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."
+  @doc "Image: Negative. Swap foreground and background"
   defsequence :inverse, 7
 
-  @doc "Image: negative. Swap foreground and background."
+  @doc "Image: Negative. Swap foreground and background"
   defsequence :reverse, 7
 
-  @doc "Conceal. Not widely supported."
+  @doc "Conceal. Not widely supported"
   defsequence :conceal, 8
 
-  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
+  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported"
   defsequence :crossed_out, 9
 
-  @doc "Sets primary (default) font."
+  @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}."
+    @doc "Sets alternative font #{font_n}"
     defsequence :"font_#{font_n}", font_n + 10
   end
 
-  @doc "Normal color or intensity."
+  @doc "Normal color or intensity"
   defsequence :normal, 22
 
-  @doc "Not italic."
+  @doc "Not italic"
   defsequence :not_italic, 23
 
-  @doc "Underline: none."
+  @doc "Underline: None"
   defsequence :no_underline, 24
 
-  @doc "Blink: off."
+  @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
-
   colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
 
   for {color, code} <- Enum.with_index(colors) do
-    @doc "Sets foreground color to #{color}."
+    @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}."
+    @doc "Sets background color to #{color}"
     defsequence :"#{color}_background", code + 40
-
-    @doc "Sets background color to light #{color}."
-    defsequence :"light_#{color}_background", code + 100
   end
 
-  @doc "Default text color."
+  @doc "Default text color"
   defsequence :default_color, 39
 
-  @doc "Default background color."
+  @doc "Default background color"
   defsequence :default_background, 49
 
-  @doc "Framed."
+  @doc "Framed"
   defsequence :framed, 51
 
-  @doc "Encircled."
+  @doc "Encircled"
   defsequence :encircled, 52
 
-  @doc "Overlined."
+  @doc "Overlined"
   defsequence :overlined, 53
 
-  @doc "Not framed or encircled."
+  @doc "Not framed or encircled"
   defsequence :not_framed_encircled, 54
 
-  @doc "Not overlined."
+  @doc "Not overlined"
   defsequence :not_overlined, 55
 
-  @doc "Sends cursor home."
+  @doc "Sends cursor home"
   defsequence :home, "", "H"
 
-  @doc "Clears screen."
+  @doc "Clears screen"
   defsequence :clear, "2", "J"
 
-  @doc "Clears line."
+  @doc "Clears line"
   defsequence :clear_line, "2", "K"
 
   defp format_sequence(other) do
@@ -198,8 +186,8 @@ defmodule IO.ANSI do
       [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
 
   """
-  def format(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
-    do_format(chardata, [], [], emit?, :maybe)
+  def format(chardata, emit \\ enabled?) when is_boolean(emit) do
+    do_format(chardata, [], [], emit, :maybe)
   end
 
   @doc ~S"""
@@ -218,12 +206,12 @@ defmodule IO.ANSI do
       [[[[[[] | "\e[1m"], 87], 111], 114], 100]
 
   """
-  def format_fragment(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
-    do_format(chardata, [], [], emit?, false)
+  def format_fragment(chardata, emit \\ enabled?) when is_boolean(emit) do
+    do_format(chardata, [], [], emit, false)
   end
 
-  defp do_format([term | rest], rem, acc, emit?, append_reset) do
-    do_format(term, [rest | rem], acc, emit?, append_reset)
+  defp do_format([term | rest], rem, acc, emit, append_reset) do
+    do_format(term, [rest | rem], acc, emit, append_reset)
   end
 
   defp do_format(term, rem, acc, true, append_reset) when is_atom(term) do
@@ -234,19 +222,19 @@ defmodule IO.ANSI do
     do_format([], rem, acc, false, append_reset)
   end
 
-  defp do_format(term, rem, acc, emit?, append_reset) when not is_list(term) do
-    do_format([], rem, [acc, term], emit?, append_reset)
+  defp do_format(term, rem, acc, emit, append_reset) when not is_list(term) do
+    do_format([], rem, [acc | [term]], emit, append_reset)
   end
 
-  defp do_format([], [next | rest], acc, emit?, append_reset) do
-    do_format(next, rest, acc, emit?, append_reset)
+  defp do_format([], [next | rest], acc, emit, append_reset) do
+    do_format(next, rest, acc, emit, append_reset)
   end
 
   defp do_format([], [], acc, true, true) do
     [acc | IO.ANSI.reset]
   end
 
-  defp do_format([], [], acc, _emit?, _append_reset) do
+  defp do_format([], [], acc, _emit, _append_reset) do
     acc
   end
 end

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

@@ -2,7 +2,6 @@ defmodule IO.ANSI.Docs do
   @moduledoc false
 
   @bullets [?*, ?-, ?+]
-  @spaces [" ", "\n", "\t"]
 
   @doc """
   The default options used by this module.
@@ -11,11 +10,11 @@ defmodule IO.ANSI.Docs do
 
     * `: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_code`          - code blocks (cyan, bright)
+    * `:doc_headings`      - h1 and h2 headings (yellow, bright)
     * `:doc_inline_code`   - inline code (cyan)
     * `:doc_table_heading` - style for table headings
-    * `:doc_title`         - top level heading (reverse, yellow)
+    * `:doc_title`         - top level heading (reverse, yellow, bright)
     * `:doc_underline`     - underlined text (underline)
     * `:width`             - the width to format the text (80)
 
@@ -25,7 +24,7 @@ defmodule IO.ANSI.Docs do
   def default_options do
     [enabled:           true,
      doc_bold:          [:bright],
-     doc_code:          [:cyan],
+     doc_code:          [:cyan, :bright],
      doc_headings:      [:yellow],
      doc_inline_code:   [:cyan],
      doc_table_heading: [:reverse],
@@ -41,12 +40,12 @@ defmodule IO.ANSI.Docs do
   """
   def print_heading(heading, options \\ []) do
     IO.puts IO.ANSI.reset
-    options = Keyword.merge(default_options(), options)
+    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)
+    heading = heading |> String.rjust(padding) |> String.ljust(width)
     write(:doc_title, heading, options)
-    newline_after_block()
+    newline_after_block
   end
 
   @doc """
@@ -56,10 +55,10 @@ defmodule IO.ANSI.Docs do
   defined in `default_options/1`.
   """
   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)
+    |> Enum.map(&String.rstrip/1)
     |> process([], "", options)
   end
 
@@ -67,23 +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.strip(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.strip(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.strip(heading), indent, options)
+    process(rest, [], "", options)
   end
 
   defp process(["" | rest], text, indent, options) do
@@ -104,7 +102,7 @@ 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) ->
@@ -120,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
@@ -147,7 +153,7 @@ defmodule IO.ANSI.Docs do
 
   defp process_list(entry, line, rest, count, indent, options) do
     # The first list always win some extra padding
-    entry = if indent == "", do: "  " <> entry, else: entry
+    if indent == "", do: entry = "  " <> entry
     new_indent = indent <> String.duplicate(" ", String.length(entry))
 
     {contents, rest, done} = process_list_next(rest, count, byte_size(new_indent), [])
@@ -191,7 +197,7 @@ defmodule IO.ANSI.Docs do
 
   defp write_text(text, indent, options) do
     case Enum.reverse(text) do
-      [:no_wrap | rest] -> write_text(rest, indent, options, true)
+      [:no_wrap|rest] -> write_text(rest, indent, options, true)
       rest -> write_text(rest, indent, options, false)
     end
   end
@@ -205,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()
@@ -223,7 +229,7 @@ defmodule IO.ANSI.Docs do
   end
 
   defp process_code(["    " <> line | rest], code, indent, options) do
-    process_code(rest, [line | code], indent, options)
+    process_code(rest, [line|code], indent, options)
   end
 
   defp process_code(rest, code, indent, options) do
@@ -244,13 +250,13 @@ defmodule IO.ANSI.Docs do
     if line === delimiter do
       process_code(rest, code, indent, options)
     else
-      process_fenced_code(rest, [line | code], indent, options, delimiter)
+      process_fenced_code(rest, [line|code], indent, options, delimiter)
     end
   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
@@ -258,7 +264,7 @@ 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
 
@@ -267,14 +273,8 @@ defmodule IO.ANSI.Docs do
     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),
@@ -285,19 +285,17 @@ defmodule IO.ANSI.Docs do
 
   defp split_into_columns(line, options) do
     line
-    |> String.trim("|")
-    |> String.trim()
-    |> String.split(" | ")
+    |> String.strip(?|)
+    |> String.strip()
+    |> 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
 
@@ -311,8 +309,6 @@ defmodule IO.ANSI.Docs do
   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
@@ -330,34 +326,14 @@ defmodule IO.ANSI.Docs do
   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?(row) do
-    Enum.all?(row, fn {col, _} -> table_header_column?(col) end)
-  end
-
-  defp table_header_column?(":" <> row), do: table_header_contents?(row)
-  defp table_header_column?(row), do: table_header_contents?(row)
-
-  defp table_header_contents?("-" <> row), do: table_header_contents?(row)
-  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)
@@ -366,22 +342,12 @@ defmodule IO.ANSI.Docs do
     end
   end
 
-  defp generate_table_cell({{{col, length}, width}, :center}) do
-    pad = if rem(length, 2) == 0, do: 1, else: rem(width, 2)
-    spaces = div(width, 2) - div(length, 2)
-    String.duplicate(" ", spaces) <> col <> String.duplicate(" ", spaces + pad)
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :right}) do
-    String.duplicate(" ", width - length) <> col
-  end
-
-  defp generate_table_cell({{{col, length}, width}, _}) do
-    col <> String.duplicate(" ", width - length)
-  end
-
   defp table_line?(line) do
-    line =~ " | "
+    Regex.match?(~r'''
+      ( ^ \s{0,3} \| (?: [^|]+ \|)+ \s* $ )
+    |
+      (\s \| \s)
+    '''x, line)
   end
 
   ## Helpers
@@ -413,13 +379,13 @@ defmodule IO.ANSI.Docs do
     write_with_wrap(rest, available, indent, false)
   end
 
-  defp take_words([word | words], available, acc) do
+  defp take_words([word|words], available, acc) do
     available = available - length_without_escape(word, 0)
 
     cond do
       # It fits, take one for space and continue decreasing
       available > 0 ->
-        take_words(words, available - 1, [word | acc])
+        take_words(words, available - 1, [word|acc])
 
       # No space but we got no words
       acc == [] ->
@@ -427,7 +393,7 @@ defmodule IO.ANSI.Docs do
 
       # Otherwise
       true ->
-        {Enum.reverse(acc), [word | words]}
+        {Enum.reverse(acc), [word|words]}
     end
   end
 
@@ -457,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
@@ -503,80 +466,80 @@ defmodule IO.ANSI.Docs do
 
   defp handle_inline(<<delimiter, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
       when rest != "" and delimiter in @delimiters do
-    handle_inline(rest, ?d, ["**"], [delimiter, Enum.reverse(buffer) | acc], options)
+    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
-    handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer) | acc], options)
+    handle_inline(rest, mark, [<<mark>>], [delimiter, Enum.reverse(buffer)|acc], options)
   end
 
   defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
       when rest != "" do
-    handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
+    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
-    handle_inline(rest, ?d, ["**"], [?\\, Enum.reverse(buffer) | acc], options)
+    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
-    handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer) | acc], options)
+    handle_inline(rest, mark, [<<mark>>], [?\\, Enum.reverse(buffer)|acc], options)
   end
 
   defp handle_inline(<<?\\, ?\\, rest::binary>>, limit, buffer, acc, options) do
-    handle_inline(rest, limit, [?\\ | buffer], acc, options)
+    handle_inline(rest, limit, [?\\|buffer], acc, options)
   end
 
   # An escape is not valid inside `
   defp handle_inline(<<?\\, mark, rest::binary>>, limit, buffer, acc, options)
       when not(mark == limit and mark == ?`) do
-    handle_inline(rest, limit, [mark | buffer], acc, options)
+    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
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+    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
-    handle_inline(<<delimiter, rest::binary>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+    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
-    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+    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
-    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
+    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options)|acc], options)
   end
 
   defp handle_inline(<<?`, rest::binary>>, ?`, buffer, acc, options) do
-    handle_inline(rest, nil, [], [inline_buffer(buffer, options) | acc], options)
+    handle_inline(rest, nil, [], [inline_buffer(buffer, options)|acc], options)
   end
 
   # Catch all
 
   defp handle_inline(<<char, rest::binary>>, mark, buffer, acc, options) do
-    handle_inline(rest, mark, [char | buffer], acc, options)
+    handle_inline(rest, mark, [char|buffer], acc, options)
   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])
-    [color_for(h, options) | t]
+    [h|t] = Enum.reverse([IO.ANSI.reset|buffer])
+    [color_for(h, options)|t]
   end
 
   defp color_for(mark, colors) do

lib/elixir/lib/io/stream.ex

@@ -18,9 +18,6 @@ defmodule IO.Stream do
     * `raw`           - a boolean indicating if bin functions should be used
     * `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.
-
   """
 
   defstruct device: nil, raw: true, line_or_bytes: :line

lib/elixir/lib/kernel/cli.ex

@@ -59,20 +59,6 @@ defmodule Kernel.CLI do
     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{} ->
-          [Exception.format_banner(kind, reason, stacktrace),
-           pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/2))]
-        _ ->
-          Exception.format_banner(kind, blamed, stacktrace)
-      end
-    [iodata, ?\n, Exception.format_stacktrace(prune_stacktrace(stacktrace))]
-  end
-
   ## Helpers
 
   defp at_exit(res) do
@@ -90,22 +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}}
+            send parent, {self, {:shutdown, 0}}
             exit(reason)
           kind, reason ->
             stack = System.stacktrace
             print_error(kind, reason, stack)
-            send parent, {self(), {:shutdown, 1}}
+            send parent, {self, {:shutdown, 1}}
             exit(to_exit(kind, reason, stack))
         else
           _ ->
-            send parent, {self(), res}
+            send parent, {self, res}
         end
       end)
 
@@ -125,7 +111,7 @@ defmodule Kernel.CLI do
 
   defp shared_option?(list, config, callback) do
     case parse_shared(list, config) do
-      {[h | hs], _} when h == hd(list) ->
+      {[h|hs], _} when h == hd(list) ->
         new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
         callback.(hs, new_config)
       {new_list, new_config} ->
@@ -133,47 +119,24 @@ defmodule Kernel.CLI do
     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
+  @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
+                     :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
+                     :elixir_def]
 
-  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_expand, :elixir_compiler, :elixir_module,
-                     :elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map,
-                     :elixir_erl, :elixir_erl_clauses, :elixir_erl_pass, Kernel.ErrorHandler]
-
-  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
+  defp prune_stacktrace([{mod, _, _, _}|t]) when mod in @elixir_internals do
     prune_stacktrace(t)
   end
 
-  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _} | _]) do
+  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _}|_]) do
     []
   end
 
-  defp prune_stacktrace([h | t]) do
-    [h | prune_stacktrace(t)]
+  defp prune_stacktrace([h|t]) do
+    [h|prune_stacktrace(t)]
   end
 
   defp prune_stacktrace([]) do
@@ -182,54 +145,59 @@ defmodule Kernel.CLI do
 
   # Parse shared options
 
-  defp parse_shared([opt | _t], _config) when opt in ["-v", "--version"] do
+  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]
+      IO.puts "IEx #{System.version}"
     else
       IO.puts :erlang.system_info(:system_version)
-      IO.puts "Elixir " <> System.build_info[:build]
+      {:ok, v} = Version.parse(System.version)
+
+      case v.pre do
+        [] -> IO.puts "Elixir #{System.version}"
+        _  -> IO.puts "Elixir #{System.version} (#{System.build_info().revision})"
+      end
     end
 
     System.halt 0
   end
 
-  defp parse_shared(["-pa", h | t], config) do
+  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}
   end
 
-  defp parse_shared(["-pz", h | t], config) do
+  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}
   end
 
-  defp parse_shared(["--app", h | t], config) do
+  defp parse_shared(["--app", h|t], config) do
     parse_shared t, %{config | commands: [{:app, h} | config.commands]}
   end
 
-  defp parse_shared(["--no-halt" | t], config) do
+  defp parse_shared(["--no-halt"|t], config) do
     parse_shared t, %{config | halt: false}
   end
 
-  defp parse_shared(["-e", h | t], config) do
+  defp parse_shared(["-e", h|t], config) do
     parse_shared t, %{config | commands: [{:eval, h} | config.commands]}
   end
 
-  defp parse_shared(["-r", h | t], config) do
+  defp parse_shared(["-r", h|t], config) do
     parse_shared t, %{config | commands: [{:require, h} | config.commands]}
   end
 
-  defp parse_shared(["-pr", h | t], config) do
+  defp parse_shared(["-pr", h|t], config) do
     parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
   end
 
-  defp parse_shared([erl, _ | t], config) when erl in ["--erl", "--sname", "--name", "--cookie", "--logger-otp-reports", "--logger-sasl-reports"] do
+  defp parse_shared([erl, _|t], config) when erl in ["--erl", "--sname", "--name", "--cookie"] do
     parse_shared t, config
   end
 
-  defp parse_shared([erl | t], config) when erl in ["--detached", "--hidden", "--werl"] do
+  defp parse_shared([erl|t], config) when erl in ["--detached", "--hidden", "--werl"] do
     parse_shared t, config
   end
 
@@ -240,30 +208,30 @@ defmodule Kernel.CLI do
   defp expand_code_path(path) do
     path = Path.expand(path)
     case Path.wildcard(path) do
-      []   -> [to_charlist(path)]
-      list -> Enum.map(list, &to_charlist/1)
+      []   -> [to_char_list(path)]
+      list -> Enum.map(list, &to_char_list/1)
     end
   end
 
   # Process init options
 
-  defp parse_argv(["--" | t], config) do
+  defp parse_argv(["--"|t], config) do
     {config, t}
   end
 
-  defp parse_argv(["+elixirc" | t], config) do
+  defp parse_argv(["+elixirc"|t], config) do
     parse_compiler t, config
   end
 
-  defp parse_argv(["+iex" | t], config) do
+  defp parse_argv(["+iex"|t], config) do
     parse_iex t, config
   end
 
-  defp parse_argv(["-S", h | t], config) do
+  defp parse_argv(["-S", h|t], config) do
     {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  defp parse_argv([h | t] = list, config) do
+  defp parse_argv([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_argv(&1, &2)
@@ -282,35 +250,35 @@ defmodule Kernel.CLI do
 
   # Parse compiler options
 
-  defp parse_compiler(["--" | t], config) do
+  defp parse_compiler(["--"|t], config) do
     {config, t}
   end
 
-  defp parse_compiler(["-o", h | t], config) do
+  defp parse_compiler(["-o", h|t], config) do
     parse_compiler t, %{config | output: h}
   end
 
-  defp parse_compiler(["--no-docs" | t], config) do
+  defp parse_compiler(["--no-docs"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--no-debug-info" | t], config) do
+  defp parse_compiler(["--no-debug-info"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:debug_info, false} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--ignore-module-conflict" | t], config) do
+  defp parse_compiler(["--ignore-module-conflict"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--warnings-as-errors" | t], config) do
+  defp parse_compiler(["--warnings-as-errors"|t], config) do
     parse_compiler t, %{config | compiler_options: [{:warnings_as_errors, true} | config.compiler_options]}
   end
 
-  defp parse_compiler(["--verbose" | t], config) do
+  defp parse_compiler(["--verbose"|t], config) do
     parse_compiler t, %{config | verbose_compile: true}
   end
 
-  defp parse_compiler([h | t] = list, config) do
+  defp parse_compiler([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_compiler(&1, &2)
@@ -321,30 +289,30 @@ defmodule Kernel.CLI do
   end
 
   defp parse_compiler([], config) do
-    {%{config | commands: [{:compile, config.compile} | config.commands]}, []}
+    {%{config | commands: [{:compile, config.compile}|config.commands]}, []}
   end
 
-  # Parse IEx options
+  # Parse iex options
 
-  defp parse_iex(["--" | t], config) do
+  defp parse_iex(["--"|t], config) do
     {config, t}
   end
 
   # This clause is here so that Kernel.CLI does not
   # error out with "unknown option"
-  defp parse_iex(["--dot-iex", _ | t], config) do
+  defp parse_iex(["--dot-iex", _|t], config) do
     parse_iex t, config
   end
 
-  defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
+  defp parse_iex([opt, _|t], config) when opt in ["--remsh"] do
     parse_iex t, config
   end
 
-  defp parse_iex(["-S", h | t], config) do
+  defp parse_iex(["-S", h|t], config) do
     {%{config | commands: [{:script, h} | config.commands]}, t}
   end
 
-  defp parse_iex([h | t] = list, config) do
+  defp parse_iex([h|t] = list, config) do
     case h do
       "-" <> _ ->
         shared_option? list, config, &parse_iex(&1, &2)
@@ -427,13 +395,8 @@ defmodule Kernel.CLI do
       {:ok, files} ->
         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 5s)")]
-            else
-              []
-            end
-          Kernel.ParallelCompiler.files_to_path(files, config.output, opts)
+          Kernel.ParallelCompiler.files_to_path(files, config.output,
+            each_file: fn file -> if config.verbose_compile do IO.puts "Compiled #{file}" end end)
         end
       {:missing, missing} ->
         {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
@@ -448,17 +411,25 @@ defmodule Kernel.CLI do
   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
+    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
 

lib/elixir/lib/kernel/error_handler.ex

@@ -3,40 +3,38 @@
 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)
+    ensure_loaded(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)
+    ensure_loaded(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
-      {:error, _} -> false
-    end
+  def release() do
+    # On release, no longer allow elixir_ensure_compiled
+    # directives and revert to the original error handler.
+    # Note we should not delete the elixir_compiler_pid though,
+    # as we still want to send notifications to the compiler.
+    :erlang.erase(:elixir_ensure_compiled)
+    :erlang.process_flag(:error_handler, :error_handler)
+    :ok
   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())
-    receive do
-      {^ref, :found}     -> true
-      {^ref, :not_found} -> false
+  defp ensure_loaded(module) do
+    case Code.ensure_loaded(module) do
+      {:module, _} -> :ok
+      {:error, _} ->
+        parent = :erlang.get(:elixir_compiler_pid)
+        ref    = :erlang.make_ref
+        send parent, {:waiting, :module, self(), ref, module}
+        :erlang.garbage_collect(self)
+        receive do
+          {^ref, :ready}   -> :ok
+          {^ref, :release} -> release()
+        end
     end
   end
 end

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -1,6 +1,8 @@
-# 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.
+#
+# The implementation simply stores dispatch information in an
+# ETS table and then consults this table once compilation is done.
 #
 # Note that since this is required for bootstrap, we can't use
 # any of the `GenServer.Behaviour` conveniences.
@@ -10,18 +12,20 @@ defmodule Kernel.LexicalTracker do
   @behaviour :gen_server
 
   @doc """
-  Returns all remotes referenced in this lexical scope.
+  Returns all remotes linked to in this lexical scope.
   """
-  def remote_references(arg) do
-    :gen_server.call(to_pid(arg), :remote_references, @timeout)
+  def remotes(arg) do
+    :gen_server.call(to_pid(arg), :ets, @timeout)
+    |> :ets.match({{:mode, :'$1'}, :'$2'})
+    |> partition([], [])
   end
 
-  @doc """
-  Returns all remote dispatches in this lexical scope.
-  """
-  def remote_dispatches(arg) do
-    :gen_server.call(to_pid(arg), :remote_dispatches, @timeout)
-  end
+  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}
 
   @doc """
   Gets the destination the lexical scope is meant to
@@ -40,7 +44,7 @@ defmodule Kernel.LexicalTracker do
 
   # Internal API
 
-  # Starts the tracker and returns its PID.
+  # Starts the tracker and returns its pid.
   @doc false
   def start_link(dest) do
     :gen_server.start_link(__MODULE__, dest, [])
@@ -52,47 +56,30 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def add_import(pid, module, fas, line, warn) when is_atom(module) do
-    :gen_server.cast(pid, {:add_import, module, fas, line, warn})
+  def add_import(pid, module, line, warn) do
+    :gen_server.cast(pid, {:add_import, module, 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
-    :gen_server.cast(pid, {:remote_reference, module, mode})
+  def remote_dispatch(pid, module, mode) do
+    :gen_server.cast(pid, {:remote_dispatch, module, mode})
   end
 
   @doc false
-  def remote_dispatch(pid, module, fa, line, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
+  def import_dispatch(pid, module) do
+    :gen_server.cast(pid, {:import_dispatch, module})
   end
 
   @doc false
-  def import_dispatch(pid, module, fa, line, mode) when is_atom(module) 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 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)
@@ -104,95 +91,61 @@ defmodule Kernel.LexicalTracker do
   end
 
   defp unused(pid, tag) do
-    :gen_server.call(pid, {:unused, tag}, @timeout)
+    :gen_server.call(pid, :ets, @timeout)
+    |> :ets.select([{{{tag, :"$1"}, :"$2"}, [is_integer: :"$2"], [{{:"$1", :"$2"}}]}])
+    |> Enum.sort
   end
 
   # Callbacks
 
   def init(dest) do
-    {:ok, %{directives: %{}, references: %{}, compile: %{},
-            runtime: %{}, dest: dest, cache: %{}}}
+    {:ok, {:ets.new(__MODULE__, [:protected]), 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}
-
-    {:reply, Enum.sort(directives), state}
+  def handle_call(:ets, _from, {d, dest}) do
+    {:reply, d, {d, dest}}
   end
 
-  def handle_call(:remote_references, _from, state) do
-    {:reply, partition(Enum.to_list(state.references), [], []), state}
+  def handle_call(:dest, _from, {d, dest}) do
+    {:reply, dest, {d, dest}}
   end
 
-  def handle_call(:remote_dispatches, _from, state) do
-    {:reply, {state.compile, state.runtime}, state}
+  def handle_cast({:remote_dispatch, module, mode}, {d, dest}) do
+    add_compile(d, module, mode)
+    {:noreply, {d, dest}}
   end
 
-  def handle_call(:dest, _from, state) do
-    {:reply, state.dest, state}
+  def handle_cast({:import_dispatch, module}, {d, dest}) do
+    add_dispatch(d, module, :import)
+    # Always compile time because we depend
+    # on the module at compile time
+    add_compile(d, module, :compile)
+    {:noreply, {d, dest}}
   end
 
-  def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
-    {:reply, Map.fetch!(cache, key), state}
+  def handle_cast({:alias_dispatch, module}, {d, dest}) do
+    add_dispatch(d, module, :alias)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
-    {:noreply, Map.put(state, :cache, Map.put(cache, key, value))}
+  def handle_cast({:add_import, module, line, warn}, {d, dest}) do
+    add_directive(d, module, line, warn, :import)
+    {:noreply, {d, dest}}
   end
 
-  def handle_cast({:remote_reference, module, mode}, state) do
-    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
+  def handle_cast({:add_alias, module, line, warn}, {d, dest}) do
+    add_directive(d, module, line, warn, :alias)
+    {:noreply, {d, dest}}
   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)
-    {:noreply, %{state | references: references}}
-  end
-
-  def handle_cast({:import_dispatch, module, {function, arity} = fa, line, mode}, state) do
-    state =
-      state
-      |> add_import_dispatch(module, function, arity)
-      |> add_remote_dispatch(module, fa, line, mode)
-
-    {:noreply, state}
-  end
-
-  def handle_cast({:alias_dispatch, module}, state) do
-    {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
-  end
-
-  def handle_cast({:add_import, module, fas, line, warn}, state) do
-    directives =
-      state.directives
-      |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
-      |> :maps.from_list
-      |> add_directive(module, line, warn, :import)
-
-    directives =
-      Enum.reduce(fas, directives, fn {function, arity}, directives ->
-        add_directive(directives, {module, function, arity}, line, warn, :import)
-      end)
-
-    {:noreply, %{state | directives: directives}}
-  end
-
-  def handle_cast({:add_alias, module, line, warn}, state) do
-    {:noreply, %{state | directives: add_directive(state.directives, module, line, warn, :alias)}}
-  end
-
-  def handle_cast(:stop, state) do
-    {:stop, :normal, state}
+  def handle_cast(:stop, {d, dest}) do
+    {:stop, :normal, {d, dest}}
   end
 
   @doc false
-  def handle_info(_msg, state) do
-    {:noreply, state}
+  def handle_info(_msg, {d, dest}) do
+    {:noreply, {d, dest}}
   end
 
   @doc false
@@ -205,62 +158,21 @@ defmodule Kernel.LexicalTracker do
     {:ok, state}
   end
 
-  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}
-
   # 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_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_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)
-
-    %{state | directives: directives, references: references}
-  end
-
-  # In the map we keep imports and aliases.
+  # In the table we keep imports and aliases.
+  # If the value is false, it was not imported/aliased
   # If the value is a line, it was imported/aliased and has a pending warning
   # If the value is true, it was imported/aliased and used
-  defp add_directive(directives, module_or_mfa, line, warn, tag) do
+  defp add_dispatch(d, module, tag) do
+    :ets.insert(d, {{tag, module}, true})
+  end
+
+  defp add_compile(d, module, :runtime), do: :ets.insert_new(d, {{:mode, module}, :runtime})
+  defp add_compile(d, module, :compile), do: :ets.insert(d, {{:mode, module}, :compile})
+
+  defp add_directive(d, module, line, warn, tag) do
     marker = if warn, do: line, else: true
-    :maps.put({tag, module_or_mfa}, marker, directives)
-  end
-
-  defp add_dispatch(directives, module_or_mfa, tag) do
-    :maps.put({tag, module_or_mfa}, true, directives)
-  end
-
-  defp map_update(key, initial, map, fun) do
-    case :maps.find(key, map) do
-      {:ok, val} -> :maps.put(key, fun.(val), map)
-      :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
+    :ets.insert(d, {{tag, module}, marker})
   end
 end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -20,21 +20,11 @@ defmodule Kernel.ParallelCompiler do
     * `:each_file` - for each file compiled, invokes the callback passing the
       file
 
-    * `:each_long_compilation` - for each file that takes more than a given
-      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_warning` - for each warning, invokes the callback passing
-      the file, line number, and warning message
-
-    * `: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 `files_to_path/3` instead.
 
@@ -62,16 +52,7 @@ defmodule Kernel.ParallelCompiler do
     :elixir_code_server.cast({:reset_warnings, compiler_pid})
     schedulers = max(:erlang.system_info(:schedulers_online), 2)
 
-    result = spawn_compilers(%{
-      entries: files,
-      original: files,
-      output: path,
-      options: options,
-      waiting: [],
-      queued: [],
-      schedulers: schedulers,
-      result: [],
-    })
+    result = spawn_compilers(files, files, path, options, [], [], schedulers, [])
 
     # In case --warning-as-errors is enabled and there was a warning,
     # compilation status will be set to error.
@@ -84,114 +65,81 @@ defmodule Kernel.ParallelCompiler do
     end
   end
 
-  # We already have n=schedulers currently running, don't spawn new ones
-  defp spawn_compilers(%{queued: queued, waiting: waiting, schedulers: schedulers} = state)
-      when length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(state)
+  # We already have 4 currently running, don't spawn new ones
+  defp spawn_compilers(entries, original, output, options, waiting, queued, schedulers, result) when
+      length(queued) - length(waiting) >= schedulers do
+    wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result)
   end
 
   # Release waiting processes
-  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}
-          waiting
-        nil ->
-          waiting
-      end
-    spawn_compilers(%{state | entries: t, waiting: waiting})
+  defp spawn_compilers([h|t], original, output, options, waiting, queued, schedulers, result) when is_pid(h) do
+    {_kind, ^h, ref, _module} = List.keyfind(waiting, h, 1)
+    send h, {ref, :ready}
+    waiting = List.keydelete(waiting, h, 1)
+    spawn_compilers(t, original, output, options, waiting, queued, schedulers, result)
   end
 
-  defp spawn_compilers(%{entries: [file | files], queued: queued, output: output, options: options} = state) do
+  # Spawn a compiler for each file in the list until we reach the limit
+  defp spawn_compilers([h|t], original, output, options, waiting, queued, schedulers, result) do
     parent = self()
 
     {pid, ref} =
       :erlang.spawn_monitor fn ->
+        # Notify Code.ensure_compiled/2 that we should
+        # attempt to compile the module by doing a dispatch.
+        :erlang.put(:elixir_ensure_compiled, true)
+
         # 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
-            _ = if output do
-              :elixir_compiler.file_to_path(file, output)
-            else
-              :elixir_compiler.file(file, Keyword.get(options, :dest))
-            end
-            :ok
-          catch
-            kind, reason ->
-              {kind, reason, System.stacktrace}
+        exit(try do
+          _ = if output do
+            :elixir_compiler.file_to_path(h, output)
+          else
+            :elixir_compiler.file(h, Keyword.get(options, :dest))
           end
-
-        send(parent, {:file_compiled, self(), file, result})
-        exit(:shutdown)
+          {:shutdown, h}
+        catch
+          kind, reason ->
+            {:failure, kind, reason, System.stacktrace}
+        end)
       end
 
-    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
-    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
-
-    new_queued = [{pid, ref, file, timer_ref} | queued]
-    spawn_compilers(%{state | entries: files, queued: new_queued})
+    spawn_compilers(t, original, output, options, waiting,
+                    [{pid, ref, h}|queued], schedulers, result)
   end
 
   # No more files, nothing waiting, queue is empty, we are done
-  defp spawn_compilers(%{entries: [], waiting: [], queued: [], result: result}) do
+  defp spawn_compilers([], _original, _output, _options, [], [], _schedulers, result) do
     for {:module, mod} <- result, do: mod
   end
 
   # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-  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
-    # 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.
-    entries
-    |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
-    |> Enum.sort_by(&length(elem(&1, 1)))
-    |> case do
-      [{_on, refs} | _] -> spawn_compilers(%{state | entries: refs})
-      [] -> handle_deadlock(waiting, queued)
+  defp spawn_compilers([], original, output, options, waiting, queued, schedulers, result) when length(waiting) == length(queued) do
+    Enum.each queued, fn {child, _, _} ->
+      {_kind, ^child, ref, _module} = List.keyfind(waiting, child, 1)
+      send child, {ref, :release}
     end
+    wait_for_messages([], original, output, options, waiting, queued, schedulers, result)
   end
 
   # No more files, but queue and waiting are not full or do not match
-  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
-      entry
-    end
+  defp spawn_compilers([], original, output, options, waiting, queued, schedulers, result) do
+    wait_for_messages([], original, output, options, waiting, queued, schedulers, result)
   end
 
   # Wait for messages from child processes
-  defp wait_for_messages(state) do
-    %{entries: entries, options: options, waiting: waiting, queued: queued, result: result} = state
-
+  defp wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result) do
     receive do
       {:struct_available, module} ->
-        available = for {:struct, _, ref, waiting_module, _defining} <- waiting,
+        available = for {:struct, pid, _, waiting_module} <- waiting,
                         module == waiting_module,
-                        do: {ref, :found}
+                        not pid in entries,
+                        do: pid
 
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
+        spawn_compilers(available ++ entries, original, output, options,
+                        waiting, queued, schedulers, [{:struct, module}|result])
 
       {:module_available, child, ref, file, module, binary} ->
         if callback = Keyword.get(options, :each_module) do
@@ -201,148 +149,116 @@ defmodule Kernel.ParallelCompiler do
         # Release the module loader which is waiting for an ack
         send child, {ref, :ack}
 
-        available = for {:module, _, ref, waiting_module, _defining} <- waiting,
+        available = for {_kind, pid, _, waiting_module} <- waiting,
                         module == waiting_module,
-                        do: {ref, :found}
+                        not pid in entries,
+                        do: pid
 
-        cancel_waiting_timer(queued, child)
+        spawn_compilers(available ++ entries, original, output, options,
+                        waiting, queued, schedulers, [{:module, module}|result])
 
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:module, module} | result]})
+      {:waiting, kind, child, ref, on} ->
+        defined = fn {k, m} -> on == m and k in [kind, :module] end
 
-      {: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}
-            waiting
-          else
-            [{kind, child, ref, on, defining} | waiting]
-          end
-
-        spawn_compilers(%{state | waiting: waiting})
-
-      {:timed_out, child} ->
-        callback = Keyword.get(options, :each_long_compilation)
-        case List.keyfind(queued, child, 0) do
-          {^child, _, file, _} when not is_nil(callback) ->
-            callback.(file)
-          _ ->
-            :ok
+        if :lists.any(defined, result) do
+          send child, {ref, :ready}
+        else
+          waiting = [{kind, child, ref, on}|waiting]
         end
-        spawn_compilers(state)
 
-      {:warning, file, line, message} ->
-        if callback = Keyword.get(options, :each_warning) do
-          callback.(file, line, message)
-        end
-        wait_for_messages(state)
-
-      {:file_compiled, child_pid, file, :ok} ->
-        discard_down(child_pid)
+        spawn_compilers(entries, original, output, options, waiting, queued, schedulers, result)
 
+      {:DOWN, _down_ref, :process, down_pid, {:shutdown, file}} ->
         if callback = Keyword.get(options, :each_file) do
           callback.(file)
         end
 
-        cancel_waiting_timer(queued, child_pid)
-
         # Sometimes we may have spurious entries in the waiting
         # list because someone invoked try/rescue UndefinedFunctionError
-        new_entries = List.delete(entries, child_pid)
-        new_queued  = List.keydelete(queued, child_pid, 0)
-        new_waiting = List.keydelete(waiting, child_pid, 1)
-        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
+        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(new_entries, original, output, options, new_waiting, new_queued, schedulers, result)
 
-      {:file_compiled, child_pid, file, {kind, reason, stack}} ->
-        discard_down(child_pid)
-        print_error(file, kind, reason, stack)
-        terminate(queued)
-
-      {:DOWN, ref, :process, _pid, reason} ->
-        handle_down(queued, ref, reason)
-        wait_for_messages(state)
+      {:DOWN, down_ref, :process, _down_pid, reason} ->
+        handle_failure(down_ref, reason, entries, waiting, queued)
+        wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result)
     end
   end
 
-  defp discard_down(pid) do
-    receive do
-      {:DOWN, _, :process, ^pid, _} -> :ok
-    end
-  end
+  defp handle_failure(ref, reason, entries, waiting, queued) do
+    if file = find_failure(ref, queued) do
+      print_failure(file, reason)
 
-  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)
-      _ ->
-        :ok
-    end
-  end
-
-  defp handle_deadlock(waiting, queued) do
-    deadlock =
-      for {pid, _, file, _} <- queued do
-        {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
-        Process.exit(pid, :kill)
-
-        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
-        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
-                                       file: nil, line: nil)
-        print_error(file, :error, error, stacktrace)
-
-        {file, on}
+      if all_missing?(entries, waiting, queued) do
+        collect_failures(queued, length(queued) - 1)
       end
 
-    IO.puts """
+      Enum.each queued, fn {child, _, _} ->
+        Process.exit(child, :kill)
+      end
 
-    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
-
-    for {file, mod} <- deadlock do
-      IO.puts ["  ", String.pad_leading(file, max), " => " | inspect(mod)]
+      exit({:shutdown, 1})
     end
-
-    IO.puts ""
-    exit({:shutdown, 1})
   end
 
-  defp terminate(queued) do
-    for {pid, _, _, _} <- queued do
-      Process.exit(pid, :kill)
+  defp find_failure(ref, queued) do
+    case List.keyfind(queued, ref, 1) do
+      {_child, ^ref, file} -> file
+      _ -> nil
     end
-    exit({:shutdown, 1})
   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 print_failure(_file, {:shutdown, _}) do
+    :ok
   end
 
-  defp cancel_waiting_timer(queued, child_pid) do
-    case List.keyfind(queued, child_pid, 0) do
-      {^child_pid, _ref, _file, timer_ref} ->
-        Process.cancel_timer(timer_ref)
-        # Let's flush the message in case it arrived before we canceled the
-        # timeout.
-        receive do
-          {:timed_out, ^child_pid} -> :ok
-        after
-          0 -> :ok
+  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]
+
+  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 all_missing?(entries, waiting, queued) do
+    entries == [] and waiting != [] and
+      length(waiting) == length(queued)
+  end
+
+  defp collect_failures(_queued, 0), do: :ok
+
+  defp collect_failures(queued, remaining) do
+    receive do
+      {:DOWN, down_ref, :process, _down_pid, reason} ->
+        if file = find_failure(down_ref, queued) do
+          print_failure(file, reason)
+          collect_failures(queued, remaining - 1)
+        else
+          collect_failures(queued, remaining)
         end
-      nil ->
-        :ok
+    after
+      # Give up if no failure appears in 5 seconds
+      5000 -> :ok
     end
   end
 end

lib/elixir/lib/kernel/parallel_require.ex

@@ -6,25 +6,16 @@ defmodule Kernel.ParallelRequire do
   @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
+  A callback that is invoked every time a file is required
+  can be optionally given as argument.
 
   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])
-  end
-
-  def files(files, callbacks) when is_list(callbacks) do
+  def files(files, callback \\ fn x -> x end) 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, [])
+    result = spawn_requires(files, [], callback, schedulers, [])
 
     # In case --warning-as-errors is enabled and there was a warning,
     # compilation status will be set to error.
@@ -32,89 +23,63 @@ defmodule Kernel.ParallelRequire do
       :ok ->
         result
       :error ->
-        IO.puts :stderr, "\nExecution failed due to warnings while using the --warnings-as-errors option"
+        IO.puts :stderr, "Compilation 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([], [], _callback, _schedulers, result), do: result
 
-  defp spawn_requires([], waiting, callbacks, schedulers, result) do
-    wait_for_messages([], waiting, callbacks, schedulers, result)
+  defp spawn_requires([], waiting, callback, schedulers, result) do
+    wait_for_messages([], waiting, callback, schedulers, result)
   end
 
-  defp spawn_requires(files, waiting, callbacks, schedulers, result) when length(waiting) >= schedulers do
-    wait_for_messages(files, waiting, callbacks, schedulers, result)
+  defp spawn_requires(files, waiting, callback, schedulers, result) when length(waiting) >= schedulers do
+    wait_for_messages(files, waiting, callback, schedulers, result)
   end
 
-  defp spawn_requires([file | files], waiting, callbacks, schedulers, result) do
+  defp spawn_requires([h|t], waiting, callback, schedulers, result) do
     parent = self()
-
     {pid, ref} = :erlang.spawn_monitor fn ->
       :erlang.put(:elixir_compiler_pid, parent)
-      :erlang.put(:elixir_compiler_file, file)
 
-      result =
-        try do
-          new = Code.require_file(file) || []
-          {:required, Enum.map(new, &elem(&1, 0))}
-        catch
-          kind, reason ->
-            {kind, reason, System.stacktrace}
-        end
-
-      send(parent, {:file_required, self(), file, result})
-      exit(:shutdown)
+      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(files, [{pid, ref} | waiting], callbacks, schedulers, result)
+    spawn_requires(t, [{pid, ref}|waiting], callback, schedulers, result)
   end
 
-  defp wait_for_messages(files, waiting, callbacks, schedulers, result) do
+  defp wait_for_messages(files, waiting, callback, schedulers, result) do
     receive do
-      {:file_required, pid, file, {:required, mods}} ->
-        discard_down(pid)
-        if each_file_callback = callbacks[:each_file] do
-          each_file_callback.(file)
+      {:DOWN, ref, :process, pid, status} ->
+        tuple = {pid, ref}
+        if tuple in waiting do
+          case status do
+            {:required, mods, file} ->
+              callback.(file)
+              result  = mods ++ result
+              waiting = List.delete(waiting, tuple)
+            {:failure, kind, reason, stacktrace} ->
+              :erlang.raise(kind, reason, stacktrace)
+            other ->
+              :erlang.raise(:exit, other, [])
+          end
         end
-        waiting = List.keydelete(waiting, pid, 0)
-        spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
-
-      {:file_required, pid, _file, {kind, reason, stacktrace}} ->
-        discard_down(pid)
-        :erlang.raise(kind, reason, stacktrace)
-
-      {:DOWN, ref, :process, pid, reason} ->
-        handle_down(waiting, pid, ref, reason)
-        spawn_requires(files, waiting, callbacks, schedulers, result)
-
-      {:module_available, child, ref, file, module, binary} ->
-        if each_module_callback = callbacks[:each_module] do
-          each_module_callback.(file, module, binary)
-        end
-
+        spawn_requires(files, waiting, callback, schedulers, result)
+      {:module_available, child, ref, _, _, _} ->
         send(child, {ref, :ack})
-        spawn_requires(files, waiting, callbacks, schedulers, result)
-
+        spawn_requires(files, waiting, callback, 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)
+        spawn_requires(files, waiting, callback, schedulers, result)
+      {:waiting, :struct, child, ref, _} ->
+        send(child, {ref, :release})
+        spawn_requires(files, waiting, callback, schedulers, result)
     end
   end
-
-  defp discard_down(pid) do
-    receive do
-      {:DOWN, _, :process, ^pid, _} -> :ok
-    end
-  end
-
-  defp handle_down(waiting, pid, ref, reason) do
-    if reason != :normal and {pid, ref} in waiting do
-      :erlang.raise(:exit, reason, [])
-    end
-    :ok
-  end
 end

lib/elixir/lib/kernel/typespec.ex

@@ -11,11 +11,8 @@ defmodule Kernel.Typespec do
 
   """
   defmacro deftype(type) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.deftype(:type, unquote(Macro.escape(type, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.deftype(:type, unquote(Macro.escape(type, unquote: true)), __ENV__)
     end
   end
 
@@ -29,11 +26,8 @@ defmodule Kernel.Typespec do
 
   """
   defmacro defopaque(type) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.deftype(:opaque, unquote(Macro.escape(type, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.deftype(:opaque, unquote(Macro.escape(type, unquote: true)), __ENV__)
     end
   end
 
@@ -47,11 +41,8 @@ defmodule Kernel.Typespec do
 
   """
   defmacro deftypep(type) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.deftype(:typep, unquote(Macro.escape(type, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.deftype(:typep, unquote(Macro.escape(type, unquote: true)), __ENV__)
     end
   end
 
@@ -65,11 +56,8 @@ defmodule Kernel.Typespec do
 
   """
   defmacro defspec(spec) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.defspec(:spec, unquote(Macro.escape(spec, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.defspec(:spec, unquote(Macro.escape(spec, unquote: true)), __ENV__)
     end
   end
 
@@ -83,14 +71,12 @@ defmodule Kernel.Typespec do
 
   """
   defmacro defcallback(spec) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.defspec(:callback, unquote(Macro.escape(spec, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.defspec(:callback, unquote(Macro.escape(spec, unquote: true)), __ENV__)
     end
   end
 
+
   @doc """
   Defines a macro callback.
   This macro is responsible for handling the attribute `@macrocallback`.
@@ -101,22 +87,31 @@ defmodule Kernel.Typespec do
 
   """
   defmacro defmacrocallback(spec) do
-    pos = :elixir_locals.cache_env(__CALLER__)
-    %{line: line, file: file, module: module} = __CALLER__
     quote do
-      Kernel.Typespec.defspec(:macrocallback, unquote(Macro.escape(spec, unquote: true)),
-                              unquote(line), unquote(file), unquote(module), unquote(pos))
+      Kernel.Typespec.defspec(:macrocallback, unquote(Macro.escape(spec, unquote: true)), __ENV__)
     end
   end
 
+  @doc """
+  Defines a `type`, `typep` or `opaque` by receiving a typespec expression.
+  """
+  def define_type(kind, expr, doc \\ nil, env) do
+    Module.store_typespec(env.module, kind, {kind, expr, doc, env})
+  end
+
+  @doc """
+  Defines a `spec` by receiving a typespec expression.
+  """
+  def define_spec(kind, expr, env) do
+    defspec(kind, expr, env)
+  end
+
   @doc """
   Returns `true` if the current module defines a given type
   (private, opaque or not). This function is only available
   for modules being compiled.
   """
-  @spec defines_type?(module, atom, arity) :: boolean
-  def defines_type?(module, name, arity)
-      when is_atom(module) and is_atom(name) and arity in 0..255 do
+  def defines_type?(module, name, arity) do
     finder = fn {_kind, expr, _caller} ->
       type_to_signature(expr) == {name, arity}
     end
@@ -128,9 +123,7 @@ defmodule Kernel.Typespec do
   Returns `true` if the current module defines a given spec.
   This function is only available for modules being compiled.
   """
-  @spec defines_spec?(module, atom, arity) :: boolean
-  def defines_spec?(module, name, arity)
-      when is_atom(module) and is_atom(name) and arity in 0..255 do
+  def defines_spec?(module, name, arity) do
     finder = fn {_kind, expr, _caller} ->
       spec_to_signature(expr) == {name, arity}
     end
@@ -141,9 +134,7 @@ defmodule Kernel.Typespec do
   Returns `true` if the current module defines a callback.
   This function is only available for modules being compiled.
   """
-  @spec defines_callback?(module, atom, arity) :: boolean
-  def defines_callback?(module, name, arity)
-      when is_atom(module) and is_atom(name) and arity in 0..255 do
+  def defines_callback?(module, name, arity) do
     finder = fn {_kind, expr, _caller} ->
       spec_to_signature(expr) == {name, arity}
     end
@@ -153,10 +144,8 @@ defmodule Kernel.Typespec do
   @doc """
   Converts a spec clause back to Elixir AST.
   """
-  @spec spec_to_ast(atom, tuple) :: {atom, keyword, [Macro.t]}
   def spec_to_ast(name, spec)
-  def spec_to_ast(name, {:type, line, :fun, [{:type, _, :product, args}, result]})
-      when is_atom(name) do
+  def spec_to_ast(name, {:type, line, :fun, [{:type, _, :product, args}, result]}) do
     meta = [line: line]
     body = {name, meta, Enum.map(args, &typespec_to_ast/1)}
 
@@ -174,12 +163,11 @@ defmodule Kernel.Typespec do
     end
   end
 
-  def spec_to_ast(name, {:type, line, :fun, []}) when is_atom(name) do
+  def spec_to_ast(name, {:type, line, :fun, []}) do
     {:::, [line: line], [{name, [line: line], []}, quote(do: term)]}
   end
 
-  def spec_to_ast(name, {:type, line, :bounded_fun, [{:type, _, :fun, [{:type, _, :product, args}, result]}, constraints]})
-      when is_atom(name) do
+  def spec_to_ast(name, {:type, line, :bounded_fun, [{:type, _, :fun, [{:type, _, :product, args}, result]}, constraints]}) do
     guards =
       for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constraints do
         {var, typespec_to_ast(type)}
@@ -208,32 +196,31 @@ defmodule Kernel.Typespec do
   def type_to_ast({{:record, record}, fields, args}) when is_atom(record) do
     fields = for field <- fields, do: typespec_to_ast(field)
     args = for arg <- args, do: typespec_to_ast(arg)
-    type = {:{}, [], [record | fields]}
+    type = {:{}, [], [record|fields]}
     quote do: unquote(record)(unquote_splicing(args)) :: unquote(type)
   end
 
-  def type_to_ast({name, type, args}) when is_atom(name) do
+  def type_to_ast({name, type, args}) do
     args = for arg <- args, do: typespec_to_ast(arg)
     quote do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_ast(type))
   end
 
+  # TODO: Deprecate by 1.2
+  # TODO: Remove by 2.0
   @doc false
-  # TODO: Remove on v2.0
   def beam_typedocs(module) when is_atom(module) or is_binary(module) do
-    IO.write :stderr, "Kernel.Typespec.beam_typedocs/1 is deprecated, please use Code.get_docs/2 instead\n" <>
-                      Exception.format_stacktrace
     if docs = Code.get_docs(module, :type_docs) do
       for {tuple, _, _, doc} <- docs, do: {tuple, doc}
     end
   end
 
   @doc """
-  Returns all types available from the module's BEAM code.
+  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
+  The module must have a corresponding beam file which can be
   located by the runtime system.
   """
   @spec beam_types(module | binary) :: [tuple] | nil
@@ -256,12 +243,12 @@ defmodule Kernel.Typespec do
   end
 
   @doc """
-  Returns all specs available from the module's BEAM code.
+  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
+  The module must have a corresponding beam file which can be
   located by the runtime system.
   """
   @spec beam_specs(module | binary) :: [tuple] | nil
@@ -270,12 +257,12 @@ defmodule Kernel.Typespec do
   end
 
   @doc """
-  Returns all callbacks available from the module's BEAM code.
+  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
+  The module must have a corresponding beam file
   which can be located by the runtime system.
   """
   @spec beam_callbacks(module | binary) :: [tuple] | nil
@@ -331,49 +318,50 @@ defmodule Kernel.Typespec do
   ## Macro callbacks
 
   @doc false
-  def defspec(kind, expr, line, file, module, pos) when kind in [:callback, :macrocallback] do
+  def defspec(kind, expr, caller) when kind in [:callback, :macrocallback] do
     case spec_to_signature(expr) do
       {name, arity} ->
-        store_callbackdoc(line, file, module, kind, name, arity)
+        store_callbackdoc(caller, caller.module, kind, name, arity)
       :error ->
         :error
     end
-    Module.store_typespec(module, kind, {kind, expr, pos})
+    Module.store_typespec(caller.module, kind, {kind, expr, caller})
   end
 
   @doc false
-  def defspec(kind, expr, _line, _file, module, pos) do
-    Module.store_typespec(module, kind, {kind, expr, pos})
+  def defspec(kind, expr, caller) do
+    Module.store_typespec(caller.module, kind, {kind, expr, caller})
   end
 
-  defp store_callbackdoc(line, _file, module, kind, name, arity) do
+  defp store_callbackdoc(caller, module, kind, name, arity) do
     table = :elixir_module.data_table(module)
-    {line, doc} = get_doc_info(table, :doc, line)
+    {line, doc} = get_doc_info(table, :doc, caller)
     :ets.insert(table, {{:callbackdoc, {name, arity}}, line, kind, doc})
   end
 
-  defp get_doc_info(table, attr, line) do
+  defp get_doc_info(table, attr, caller) do
     case :ets.take(table, attr) do
-      [{^attr, {line, doc}, _, _}] -> {line, doc}
-      [] -> {line, nil}
+      [{^attr, {line, doc}}] -> {line, doc}
+      [] -> {caller.line, nil}
     end
   end
 
   @doc false
-  def deftype(kind, expr, line, file, module, pos) do
+  def deftype(kind, expr, caller) do
+    module = caller.module
     case type_to_signature(expr) do
-      {name, arity} -> store_typedoc(line, file, module, kind, name, arity)
+      {name, arity} -> store_typedoc(caller, caller.module, kind, name, arity)
       :error -> :error
     end
-    Module.store_typespec(module, kind, {kind, expr, pos})
+    Module.store_typespec(module, kind, {kind, expr, caller})
   end
 
-  defp store_typedoc(line, file, module, kind, name, arity) do
+  defp store_typedoc(caller, module, kind, name, arity) do
     table = :elixir_module.data_table(module)
-    {line, doc} = get_doc_info(table, :typedoc, line)
+    {line, doc} = get_doc_info(table, :typedoc, caller)
 
     if kind == :typep && doc do
-      :elixir_errors.warn(line, file, "type #{name}/#{arity} is private, " <>
+      :elixir_errors.warn(caller.line, caller.file, "type #{name}/#{arity} is private, " <>
                           "@typedoc's are always discarded for private types")
     end
 
@@ -383,9 +371,7 @@ defmodule Kernel.Typespec do
   ## Translation from Elixir AST to typespec AST
 
   @doc false
-  def translate_type(kind, {:::, _, [{name, _, args}, definition]}, pos) when is_atom(name) and name != ::: do
-    caller = :elixir_locals.get_cached_env(pos)
-
+  def translate_type(kind, {:::, _, [{name, _, args}, definition]}, caller) when is_atom(name) and name != ::: do
     args =
       if is_atom(args) do
         []
@@ -406,43 +392,59 @@ defmodule Kernel.Typespec do
         :opaque -> {:opaque, true}
       end
 
-    if builtin_type?(name, arity) do
-      compile_error caller, "type #{name}/#{arity} is a builtin type and it cannot be redefined"
+    if elixir_builtin_type?(name, arity) do
+      :elixir_errors.handle_file_error(caller.file,
+        {caller.line, :erl_lint, {:builtin_type, {name, arity}}})
     end
 
     {{kind, {name, arity}, type}, caller.line, export}
   end
 
-  def translate_type(_kind, other, pos) do
-    caller = :elixir_locals.get_cached_env(pos)
+  def translate_type(_kind, other, caller) do
     type_spec = Macro.to_string(other)
     compile_error caller, "invalid type specification: #{type_spec}"
   end
 
-  defp builtin_type?(:as_boolean, 1), do: true
-  defp builtin_type?(:struct, 0), do: true
-  defp builtin_type?(:charlist, 0), do: true
-  # TODO: Remove char_list type by 2.0
-  defp builtin_type?(:char_list, 0), do: true
-  defp builtin_type?(:nonempty_charlist, 0), do: true
-  defp builtin_type?(:keyword, 0), do: true
-  defp builtin_type?(:keyword, 1), do: true
-  defp builtin_type?(name, arity), do: :erl_internal.is_type(name, arity)
+  defp elixir_builtin_type?(:as_boolean, 1), do: true
+  defp elixir_builtin_type?(:struct, 0), do: true
+  defp elixir_builtin_type?(:char_list, 0), do: true
+  defp elixir_builtin_type?(_, _), do: false
 
   @doc false
-  def translate_spec(kind, {:when, _meta, [spec, guard]}, pos) do
-    caller = :elixir_locals.get_cached_env(pos)
+  def translate_spec(kind, {:when, _meta, [spec, guard]}, caller) do
     translate_spec(kind, spec, guard, caller)
   end
 
-  def translate_spec(kind, spec, pos) do
-    caller = :elixir_locals.get_cached_env(pos)
+  def translate_spec(kind, spec, caller) do
     translate_spec(kind, spec, [], caller)
   end
 
-  defp translate_spec(kind, {:::, meta, [{name, _, args}, return]}, guard, caller)
-      when is_atom(name) and name != ::: do
-    translate_spec(kind, meta, name, args, return, guard, caller)
+  defp translate_spec(kind, {:::, meta, [{name, _, args}, return]}, guard, caller) when is_atom(name) and name != ::: do
+    if is_atom(args), do: args = []
+
+    if kind == :macrocallback do
+      kind = :callback
+      name = :"MACRO-#{name}"
+      args = [quote(do: env :: Macro.Env.t)|args]
+    end
+
+    ensure_no_defaults! args
+
+    unless Keyword.keyword?(guard) do
+      guard = Macro.to_string(guard)
+      compile_error caller, "expected keywords as guard in type specification, got: #{guard}"
+    end
+
+    vars = Keyword.keys(guard)
+    constraints = guard_to_constraints(guard, vars, meta, caller)
+
+    spec = {:type, line(meta), :fun, fn_args(meta, args, return, vars, caller)}
+    if constraints != [] do
+      spec = {:type, line(meta), :bounded_fun, [spec, constraints]}
+    end
+
+    arity = length(args)
+    {{kind, {name, arity}, spec}, caller.line}
   end
 
   defp translate_spec(_kind, {name, _meta, _args} = spec, _guard, caller) when is_atom(name) and name != ::: do
@@ -455,29 +457,6 @@ defmodule Kernel.Typespec do
     compile_error caller, "invalid type specification: #{spec}"
   end
 
-  defp translate_spec(kind, meta, name, args, return, guard, caller) when is_atom(args),
-    do: translate_spec(kind, meta, name, [], return, guard, caller)
-  defp translate_spec(kind, meta, name, args, return, guard, caller) do
-    ensure_no_defaults!(args)
-
-    unless Keyword.keyword?(guard) do
-      compile_error caller, "expected keywords as guard in type specification, " <>
-                            "got: #{Macro.to_string(guard)}"
-    end
-
-    vars = Keyword.keys(guard)
-    spec = {:type, line(meta), :fun, fn_args(meta, args, return, vars, caller)}
-
-    spec =
-      case guard_to_constraints(guard, vars, meta, caller) do
-        [] -> spec
-        constraints -> {:type, line(meta), :bounded_fun, [spec, constraints]}
-      end
-
-    arity = length(args)
-    {{kind, {name, arity}, spec}, caller.line}
-  end
-
   defp ensure_no_defaults!(args) do
     :lists.foreach fn
       {:::, _, [left, right]} ->
@@ -505,7 +484,7 @@ defmodule Kernel.Typespec do
       {name, type}, acc ->
         constraint = [{:atom, line, :is_subtype}, [{:var, line, name}, typespec(type, vars, caller)]]
         type = {:type, line, :constraint, constraint}
-        [type | acc]
+        [type|acc]
     end, [], guard) |> :lists.reverse
   end
 
@@ -581,14 +560,12 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast({: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_ast(v)}
-      {:type, _, :map_field_exact, [k, v]} ->
-        {{:required, [], [typespec_to_ast(k)]}, typespec_to_ast(v)}
+      # OTP 18
       {:type, _, :map_field_assoc, [k, v]} ->
-        {{:optional, [], [typespec_to_ast(k)]}, typespec_to_ast(v)}
+        {typespec_to_ast(k), typespec_to_ast(v)}
+      # OTP 17
+      {:type, _, :map_field_assoc, k, v} ->
+        {typespec_to_ast(k), typespec_to_ast(v)}
     end
 
     {struct, fields} = Keyword.pop(fields, :__struct__)
@@ -628,7 +605,7 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec_to_ast({:type, line, :fun, []}) do
-    typespec_to_ast({:type, line, :fun, [{:type, line, :any}, {:type, line, :any, []}]})
+    typespec_to_ast({:type, line, :fun, [{:type, line, :any}, {:type, line, :any, []} ]})
   end
 
   defp typespec_to_ast({:type, line, :range, [left, right]}) do
@@ -653,14 +630,8 @@ defmodule Kernel.Typespec do
   end
 
   # Special shortcut(s)
-  # TODO: Remove char_list type by 2.0
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, type}, []]})
-      when type in [:charlist, :char_list] do
-    typespec_to_ast({:type, line, :charlist, []})
-  end
-
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []]}) do
-    typespec_to_ast({:type, line, :nonempty_charlist, []})
+  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :char_list}, []]}) do
+    typespec_to_ast({:type, line, :char_list, []})
   end
 
   defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :struct}, []]}) do
@@ -671,10 +642,6 @@ defmodule Kernel.Typespec do
     typespec_to_ast({:type, line, :as_boolean, [arg]})
   end
 
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, :keyword}, args]}) do
-    typespec_to_ast({:type, line, :keyword, args})
-  end
-
   defp typespec_to_ast({:remote_type, line, [mod, name, args]}) do
     args = for arg <- args, do: typespec_to_ast(arg)
     dot  = {:., [line: line], [typespec_to_ast(mod), typespec_to_ast(name)]}
@@ -758,23 +725,11 @@ defmodule Kernel.Typespec do
   defp typespec({:%{}, meta, fields} = map, vars, caller) do
     fields =
       :lists.map(fn
-        {k, v} when is_atom(k) ->
-          {:type, line(meta), :map_field_exact, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {{:required, meta2, [k]}, v} ->
-          {:type, line(meta2), :map_field_exact, [typespec(k, vars, caller), typespec(v, vars, caller)]}
-        {{:optional, meta2, [k]}, v} ->
-          {:type, line(meta2), :map_field_assoc, [typespec(k, vars, caller), typespec(v, vars, caller)]}
         {k, v} ->
-          # TODO: Emit warnings on v1.6 (when we drop OTP 18 support)
-          # :elixir_errors.warn(caller.line, caller.file,
-          #   "invalid map specification. %{foo => bar} is deprecated in favor of " <>
-          #   "%{required(foo) => bar} and %{optional(foo) => bar}. required/1 is an " <>
-          #   "OTP 19 only feature, if you are targeting OTP 18 use optional/1.")
           {:type, line(meta), :map_field_assoc, [typespec(k, vars, caller), typespec(v, vars, caller)]}
         {:|, _, [_, _]} ->
-          compile_error(caller,
-            "invalid map specification. When using the | operator in the map key, " <>
-            "make sure to wrap the key type in parentheses: #{Macro.to_string(map)}")
+          compile_error(caller, "invalid map specification. When using the | operator in the map key, " <>
+                                "make sure to wrap the key type in parentheses: #{Macro.to_string(map)}")
         _ ->
           compile_error(caller, "invalid map specification: #{Macro.to_string(map)}")
       end, fields)
@@ -783,8 +738,6 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec({:%, _, [name, {:%{}, meta, fields}]}, vars, caller) do
-    # We cannot set a function name to avoid tracking
-    # as a compile time dependency, because for structs it actually is one.
     module = Macro.expand(name, caller)
 
     struct =
@@ -821,8 +774,6 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec({:record, meta, [atom, fields]}, vars, caller) do
-    # We cannot set a function name to avoid tracking
-    # as a compile time dependency because for records it actually is one.
     case Macro.expand({atom, [], [{atom, [], []}]}, caller) do
       keyword when is_list(keyword) ->
         types =
@@ -836,7 +787,7 @@ defmodule Kernel.Typespec do
           end
         end, fields)
 
-        typespec({:{}, meta, [atom | types]}, vars, caller)
+        typespec({:{}, meta, [atom|types]}, vars, caller)
       _ ->
         compile_error(caller, "unknown record #{inspect atom}")
     end
@@ -868,7 +819,7 @@ defmodule Kernel.Typespec do
 
   # Handle type operator
   defp typespec({:::, meta, [var, expr]}, vars, caller) do
-    left  = typespec(var, [elem(var, 0) | vars], caller)
+    left  = typespec(var, [elem(var, 0)|vars], caller)
     right = typespec(expr, vars, caller)
     {:ann_type, line(meta), [left, right]}
   end
@@ -878,24 +829,9 @@ defmodule Kernel.Typespec do
     {:op, line(meta), op, {:integer, line(meta), integer}}
   end
 
-  # Handle remote calls in the form of @module_attribute.type.
-  # These are not handled by the general remote type clause as calling
-  # Macro.expand/2 on the remote does not expand module attributes (but expands
-  # things like __MODULE__).
-  defp typespec({{:., meta, [{:@, _, [{attr, _, _}]}, name]}, _, args} = orig, vars, caller) do
-    remote = Module.get_attribute(caller.module, attr)
-    unless is_atom(remote) and remote != nil do
-      message = "invalid remote in typespec: #{Macro.to_string(orig)} (@#{attr} is #{inspect remote})"
-      compile_error(caller, message)
-    end
-    remote_type({typespec(remote, vars, caller), meta, typespec(name, vars, caller), args}, vars, caller)
-  end
-
   # Handle remote calls
   defp typespec({{:., meta, [remote, name]}, _, args} = orig, vars, caller) do
-    # We set a function name to avoid tracking
-    # aliases in typespecs as compile time dependencies.
-    remote = Macro.expand(remote, %{caller | function: {:typespec, 0}})
+    remote = Macro.expand remote, caller
     unless is_atom(remote) do
       compile_error(caller, "invalid remote in typespec: #{Macro.to_string(orig)}")
     end
@@ -903,7 +839,7 @@ defmodule Kernel.Typespec do
   end
 
   # Handle tuples
-  defp typespec({:tuple, meta, []}, _vars, _caller) do
+  defp typespec({:tuple, meta, args}, _vars, _caller) when args == [] or is_atom(args) do
     {:type, line(meta), :tuple, :any}
   end
 
@@ -931,36 +867,15 @@ defmodule Kernel.Typespec do
   end
 
   # Handle local calls
-  defp typespec({:string, meta, arguments}, vars, caller) do
-    :elixir_errors.warn caller.line, caller.file,
-      "string() type use is discouraged. " <>
-      "For character lists, use charlist() type, for strings, String.t()\n" <>
-      Exception.format_stacktrace(Macro.Env.stacktrace(caller))
-
+  defp typespec({type, meta, arguments}, vars, caller) when type in [:string, :nonempty_string] do
+    :elixir_errors.warn caller.line, caller.file, "#{type}() type use is discouraged. For character lists, use " <>
+      "char_list() type, for strings, String.t()\n#{Exception.format_stacktrace(Macro.Env.stacktrace(caller))}"
     arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:type, line(meta), :string, arguments}
+    {:type, line(meta), type, arguments}
   end
 
-  defp typespec({:nonempty_string, meta, arguments}, vars, caller) do
-    :elixir_errors.warn caller.line, caller.file,
-      "nonempty_string() type use is discouraged. " <>
-      "For non-empty character lists, use nonempty_charlist() type, for strings, String.t()\n" <>
-      Exception.format_stacktrace(Macro.Env.stacktrace(caller))
-
-    arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:type, line(meta), :nonempty_string, arguments}
-  end
-
-  # TODO: Remove char_list type by 2.0
-  defp typespec({type, _meta, []}, vars, caller) when type in [:charlist, :char_list] do
-    if type == :char_list do
-      :elixir_errors.warn caller.line, caller.file, "the char_list() type is deprecated, use charlist()"
-    end
-    typespec((quote do: :elixir.charlist()), vars, caller)
-  end
-
-  defp typespec({:nonempty_charlist, _meta, []}, vars, caller) do
-    typespec((quote do: :elixir.nonempty_charlist()), vars, caller)
+  defp typespec({:char_list, _meta, []}, vars, caller) do
+    typespec((quote do: :elixir.char_list()), vars, caller)
   end
 
   defp typespec({:struct, _meta, []}, vars, caller) do
@@ -971,10 +886,6 @@ defmodule Kernel.Typespec do
     typespec((quote do: :elixir.as_boolean(unquote(arg))), vars, caller)
   end
 
-  defp typespec({:keyword, _meta, args}, vars, caller) when length(args) <= 1 do
-    typespec((quote do: :elixir.keyword(unquote_splicing(args))), vars, caller)
-  end
-
   defp typespec({:fun, meta, args}, vars, caller) do
     args = for arg <- args, do: typespec(arg, vars, caller)
     {:type, line(meta), :fun, args}
@@ -1013,7 +924,7 @@ defmodule Kernel.Typespec do
   end
 
   defp typespec(list, vars, caller) when is_list(list) do
-    [h | t] = :lists.reverse(list)
+    [h|t] = :lists.reverse(list)
     union = :lists.foldl(fn(x, acc) ->
       {:|, [], [validate_kw(x, list, caller), acc]}
     end, validate_kw(h, list, caller), t)
@@ -1032,10 +943,10 @@ defmodule Kernel.Typespec do
 
   defp remote_type({remote, meta, name, arguments}, vars, caller) do
     arguments = for arg <- arguments, do: typespec(arg, vars, caller)
-    {:remote_type, line(meta), [remote, name, arguments]}
+    {:remote_type, line(meta), [ remote, name, arguments ]}
   end
 
-  defp collect_union({:|, _, [a, b]}), do: [a | collect_union(b)]
+  defp collect_union({:|, _, [a, b]}), do: [a|collect_union(b)]
   defp collect_union(v), do: [v]
 
   defp validate_kw({key, _} = t, _, _caller) when is_atom(key), do: t
@@ -1063,8 +974,8 @@ defmodule Kernel.Typespec do
     {:var, line(meta), name}
   end
 
-  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do
-    unpack_typespec_kw(t, [{atom, typespec_to_ast(type)} | acc])
+  defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]}|t], acc) do
+    unpack_typespec_kw(t, [{atom, typespec_to_ast(type)}|acc])
   end
 
   defp unpack_typespec_kw([], acc) do

lib/elixir/lib/kernel/utils.ex

@@ -3,27 +3,18 @@ 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)
-  defp destructure_list([h | t], count), do: [h | destructure_list(t, count - 1)]
+  defp destructure_list([h|t], count), do: [h|destructure_list(t, count - 1)]
 
   defp destructure_nil(0), do: []
-  defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
+  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, env) do
+    append_first = Keyword.get(opts, :append_first, false)
 
     {name, args} =
       case Macro.decompose_call(fun) do
@@ -31,39 +22,32 @@ defmodule Kernel.Utils do
         _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
       end
 
-    as = Keyword.get(opts, :as, name)
-    as_args = build_as_args(args, append_first?)
+    :ok = check_defdelegate_args(args, env)
 
+    as_args =
+      case append_first and args != [] do
+        true  -> tl(args) ++ [hd(args)]
+        false -> args
+      end
+
+    as = Keyword.get(opts, :as, name)
     {name, args, as, as_args}
   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
+  # TODO: Convert this to an error on 1.3
+  defp check_defdelegate_args([], _env),
+    do: :ok
+  defp check_defdelegate_args([{var, _, mod}|rest], env) when is_atom(var) and is_atom(mod),
+    do: check_defdelegate_args(rest, env)
+  defp check_defdelegate_args([code|_], env) do
+    :elixir_errors.warn(env.line, env.file,
+      "defdelegate/2 will only accept variable names in upcoming versions, " <>
+      "got: #{Macro.to_string(code)}")
   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
-  end
-
-  defp validate_arg(ast) do
-    raise ArgumentError, "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
-  end
-
-  @doc """
-  Callback for defstruct.
-  """
   def defstruct(module, fields) do
     case fields do
-      fs when is_list(fs) ->
-        :ok
+      fs when is_list(fs) -> :ok
       other ->
         raise ArgumentError, "struct fields definition must be list, got: #{inspect other}"
     end
@@ -84,42 +68,6 @@ defmodule Kernel.Utils do
         raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
     end, fields)
 
-    enforce_keys = List.wrap(Module.get_attribute(module, :enforce_keys))
-
-    :lists.foreach(fn
-      key when is_atom(key) -> :ok
-      key -> raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect key}"
-    end, enforce_keys)
-
-    {:maps.put(:__struct__, module, :maps.from_list(fields)),
-     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(atom) when is_atom(atom) do
-    atom.exception([])
-  end
-  def raise(%{__struct__: struct, __exception__: true} = exception) when is_atom(struct) do
-    exception
-  end
-  def raise(other) do
-    ArgumentError.exception("raise/1 expects a module name, string or exception as " <>
-                            "the first argument, got: #{inspect other}")
+    :maps.put(:__struct__, module, :maps.from_list(fields))
   end
 end

lib/elixir/lib/keyword.ex

@@ -2,37 +2,12 @@ defmodule Keyword do
   @moduledoc """
   A set of functions for working with keywords.
 
-  A keyword is a list of two-element tuples where the first
+  A keyword is a list of 2-element tuples where the first
   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. 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
+  a dictionary. However most of the functions in this module
   behave exactly as a dictionary so they work similarly to
   the functions you would find in the `Map` module.
 
@@ -40,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
@@ -51,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
@@ -100,7 +71,7 @@ defmodule Keyword do
       []
 
   """
-  @spec new :: []
+  @spec new :: t
   def new, do: []
 
   @doc """
@@ -133,7 +104,7 @@ 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]
 
   """
@@ -174,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
@@ -219,14 +191,12 @@ defmodule Keyword do
   Gets the value from `key` and updates it, all in one pass.
 
   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
-  keyword list and returned.
+  is not present) and must return a two-elements 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 keyword list with the updated value under `key`.
+  The returned value is a tuple with the "get" value returned by `fun` and a new
+  keyword list with the updated value under `key`.
 
   ## Examples
 
@@ -240,48 +210,30 @@ defmodule Keyword do
       ...> end)
       {nil, [b: "new value!", a: 1]}
 
-      iex> Keyword.get_and_update([a: 1], :a, fn _ -> :pop end)
-      {1, []}
-
-      iex> Keyword.get_and_update([a: 1], :b, fn _ -> :pop end)
-      {nil, [a: 1]}
-
   """
-  @spec get_and_update(t, key, (value -> {get, value} | :pop)) :: {get, t} when get: term
+  @spec get_and_update(t, key, (value -> {get, value})) :: {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)
 
-  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)}"
-    end
+  defp get_and_update([{key, value}|t], acc, key, fun) do
+    {get, new_value} = fun.(value)
+    {get, :lists.reverse(acc, [{key, new_value}|t])}
   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)}"
-    end
+    {get, update} = fun.(nil)
+    {get, [{key, update}|:lists.reverse(acc)]}
   end
 
   @doc """
   Gets the value from `key` and updates it. Raises if there is no `key`.
 
   This `fun` argument receives the value of `key` and must return a
-  two-element tuple: the "get" value (the retrieved value, which can be
+  two-elements tuple: the "get" value (the retrieved value, which can be
   operated on before being returned) and the new value to be stored under
   `key`.
 
@@ -290,7 +242,7 @@ defmodule Keyword do
 
   ## Examples
 
-      iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
+      iex> Keyword.get_and_update!([a: 1], :a, fn(current_value) ->
       ...>   {current_value, "new value!"}
       ...> end)
       {1, [a: "new value!"]}
@@ -300,30 +252,19 @@ defmodule Keyword do
       ...> end)
       ** (KeyError) key :b not found in: [a: 1]
 
-      iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, []}
-
   """
   @spec get_and_update!(t, key, (value -> {get, value})) :: {get, t} | no_return when get: term
   def get_and_update!(keywords, key, fun) do
     get_and_update!(keywords, key, fun, [])
   end
 
-  defp get_and_update!([{key, value} | keywords], key, fun, acc) 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
+  defp get_and_update!([{key, value}|keywords], key, fun, acc) do
+    {get, value} = fun.(value)
+    {get, :lists.reverse(acc, [{key, value}|delete(keywords, key)])}
   end
 
-  defp get_and_update!([{_, _} = e | keywords], key, fun, acc) do
-    get_and_update!(keywords, key, fun, [e | acc])
+  defp get_and_update!([{_, _} = e|keywords], key, fun, acc) do
+    get_and_update!(keywords, key, fun, [e|acc])
   end
 
   defp get_and_update!([], key, _fun, acc) when is_atom(key) do
@@ -388,7 +329,7 @@ defmodule Keyword do
   @spec get_values(t, key) :: [value]
   def get_values(keywords, key) when is_list(keywords) and is_atom(key) do
     fun = fn
-      {^key, val} -> {true, val}
+      {k, v} when k === key -> {true, v}
       {_, _} -> false
     end
     :lists.filtermap(fun, keywords)
@@ -510,7 +451,7 @@ defmodule Keyword do
   """
   @spec put(t, key, value) :: t
   def put(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    [{key, value} | delete(keywords, key)]
+    [{key, value}|delete(keywords, key)]
   end
 
   @doc """
@@ -538,7 +479,7 @@ defmodule Keyword do
       when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, _} -> keywords
-      false -> [{key, fun.()} | keywords]
+      false -> [{key, fun.()}|keywords]
     end
   end
 
@@ -558,50 +499,7 @@ defmodule Keyword do
   def put_new(keywords, key, value) when is_list(keywords) and is_atom(key) do
     case :lists.keyfind(key, 1, keywords) do
       {^key, _} -> keywords
-      false -> [{key, value} | keywords]
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in the keyword list.
-
-  In the case a value is stored multiple times in the keyword list,
-  later occurrences are removed.
-
-  ## Examples
-
-      iex> Keyword.replace([a: 1], :b, 2)
-      [a: 1]
-      iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
-      [a: 3, b: 2]
-
-  """
-  @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 -> keywords
-    end
-  end
-
-  @doc """
-  Similar to `replace/3`, but will raise a `KeyError`
-  if the entry `key` does not exist.
-
-  ## 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]
-
-  """
-  @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
+      false -> [{key, value}|keywords]
     end
   end
 
@@ -642,23 +540,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) 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 """
@@ -689,40 +575,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} ->
-        do_merge(tail, [{key, fun.(key, value1, value2)} | acc],
-                 delete(rest, key), :lists.keydelete(key, 1, 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`.
 
@@ -763,12 +635,12 @@ defmodule Keyword do
     update!(keywords, key, fun, keywords)
   end
 
-  defp update!([{key, value} | keywords], key, fun, _dict) do
-    [{key, fun.(value)} | delete(keywords, key)]
+  defp update!([{key, value}|keywords], key, fun, _dict) do
+    [{key, fun.(value)}|delete(keywords, key)]
   end
 
-  defp update!([{_, _} = e | keywords], key, fun, dict) do
-    [e | update!(keywords, key, fun, dict)]
+  defp update!([{_, _} = e|keywords], key, fun, dict) do
+    [e|update!(keywords, key, fun, dict)]
   end
 
   defp update!([], key, _fun, dict) when is_atom(key) do
@@ -796,12 +668,12 @@ defmodule Keyword do
   @spec update(t, key, value, (value -> value)) :: t
   def update(keywords, key, initial, fun)
 
-  def update([{key, value} | keywords], key, _initial, fun) do
-    [{key, fun.(value)} | delete(keywords, key)]
+  def update([{key, value}|keywords], key, _initial, fun) do
+    [{key, fun.(value)}|delete(keywords, key)]
   end
 
-  def update([{_, _} = e | keywords], key, initial, fun) do
-    [e | update(keywords, key, initial, fun)]
+  def update([{_, _} = e|keywords], key, initial, fun) do
+    [e|update(keywords, key, initial, fun)]
   end
 
   def update([], key, initial, _fun) when is_atom(key) do
@@ -814,7 +686,7 @@ defmodule Keyword do
 
   Returns a tuple with the new list and the old list with removed keys.
 
-  Keys for which there are no entries in the keyword list are ignored.
+  Keys for which there are no entires in the keyword list are ignored.
 
   Entries with duplicated keys end up in the same keyword list.
 
@@ -826,12 +698,11 @@ 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}
-        false -> {take, [{k, v} | drop]}
+        true  -> {[{k, v}|take], drop}
+        false -> {take, [{k, v}|drop]}
       end
     end
 
@@ -854,7 +725,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
@@ -872,9 +742,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 """
@@ -945,13 +814,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]}
 
   """
@@ -972,14 +841,13 @@ defmodule Keyword do
       [a: 1]
 
   """
-  @spec to_list(t) :: t
   def to_list(keyword) when is_list(keyword) do
     keyword
   end
 
+  # TODO: Deprecate by 1.3
+  # TODO: Remove by 1.4
   @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
   def size(keyword) do
     length(keyword)
   end

lib/elixir/lib/list.ex

@@ -1,80 +1,38 @@
 defmodule List do
   @moduledoc """
-  Functions that work on (linked) lists.
+  Specialized functions that only work on lists.
 
-  Lists in Elixir are specified between square brackets:
+  In general, favor using the `Enum` API instead of `List`.
 
-      iex> [1, "two", 3, :four]
-      [1, "two", 3, :four]
+  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.
 
-  Two lists can be concatenated and subtracted using the
-  `Kernel.++/2` and `Kernel.--/2` operators:
+  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.
 
-      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]
+  ## Char lists
 
-  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]
-
-  The `Kernel` module contains many functions to manipulate lists
-  and that are allowed in guards. For example, `Kernel.hd/1` to
-  retrieve the head, `Kernel.tl/1` to fetch the tail and
-  `Kernel.length/1` for calculating the length. Keep in mind that,
-  similar to appending to a list, calculating the length needs to
-  traverse the whole list.
-
-  ## 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 char list. Elixir uses single quotes to
+  define char lists:
 
       iex> 'héllo'
       [104, 233, 108, 108, 111]
 
-  In particular, charlists may be printed back in single
+  In particular, char lists may be printed back in single
   quotes if they contain only ASCII-printable codepoints:
 
       iex> 'abc'
       'abc'
 
   The rationale behind this behaviour is to better support
-  Erlang libraries which may return text as charlists
+  Erlang libraries which may return text as char lists
   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'},
@@ -82,44 +40,28 @@ defmodule List do
             {:elixir, 'elixir', '1.0.0'},
             {:kernel, 'ERTS  CXC 138 10', '4.1'},
             {:logger, 'logger', '1.0.0'}]
-
-  ## List and Enum modules
-
-  This module aims to provide operations that are specific
-  to lists, like conversion between data types, updates,
-  deletions and key lookups (for lists of tuples). For traversing
-  lists in general, developers should use the functions in the
-  `Enum` module that work across a variety of data types.
-
-  In both `Enum` and `List` modules, any kind of index access
-  on a 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.
   """
 
   @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.
@@ -132,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
@@ -174,10 +117,10 @@ 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
 
   """
@@ -192,7 +135,7 @@ 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
 
   """
@@ -217,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.
@@ -236,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
@@ -279,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
@@ -318,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
 
@@ -338,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.
 
@@ -388,7 +330,6 @@ defmodule List do
 
   @doc """
   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.
 
@@ -439,9 +380,8 @@ defmodule List do
 
   @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
 
@@ -459,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
@@ -469,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
@@ -489,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
@@ -499,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
@@ -519,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
@@ -529,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
@@ -546,73 +483,18 @@ 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]}
-
-  """
-  @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`.
+  Converts a char list to an atom.
 
-  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
-
-  """
-  @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.
-
-  Currently Elixir does not support conversions from charlists
+  Currently Elixir does not support conversions from char lists
   which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
@@ -623,16 +505,16 @@ defmodule List do
       :elixir
 
   """
-  @spec to_atom(charlist) :: atom
-  def to_atom(charlist) do
-    :erlang.list_to_atom(charlist)
+  @spec to_atom(char_list) :: atom
+  def to_atom(char_list) do
+    :erlang.list_to_atom(char_list)
   end
 
   @doc """
-  Converts a charlist to an existing atom. Raises an `ArgumentError`
+  Converts a char list to an existing atom. Raises an `ArgumentError`
   if the atom does not exist.
 
-  Currently Elixir does not support conversions from charlists
+  Currently Elixir does not support conversions from char lists
   which contains Unicode codepoints greater than 0xFF.
 
   Inlined by the compiler.
@@ -647,13 +529,13 @@ defmodule List do
       ** (ArgumentError) argument error
 
   """
-  @spec to_existing_atom(charlist) :: atom
-  def to_existing_atom(charlist) do
-    :erlang.list_to_existing_atom(charlist)
+  @spec to_existing_atom(char_list) :: atom
+  def to_existing_atom(char_list) do
+    :erlang.list_to_existing_atom(char_list)
   end
 
   @doc """
-  Returns the float whose text representation is `charlist`.
+  Returns the float whose text representation is `char_list`.
 
   Inlined by the compiler.
 
@@ -663,13 +545,13 @@ defmodule List do
       2.2017764
 
   """
-  @spec to_float(charlist) :: float
-  def to_float(charlist) do
-    :erlang.list_to_float(charlist)
+  @spec to_float(char_list) :: float
+  def to_float(char_list) do
+    :erlang.list_to_float(char_list)
   end
 
   @doc """
-  Returns an integer whose text representation is `charlist`.
+  Returns an integer whose text representation is `char_list`.
 
   Inlined by the compiler.
 
@@ -679,13 +561,13 @@ defmodule List do
       123
 
   """
-  @spec to_integer(charlist) :: integer
-  def to_integer(charlist) do
-    :erlang.list_to_integer(charlist)
+  @spec to_integer(char_list) :: integer
+  def to_integer(char_list) do
+    :erlang.list_to_integer(char_list)
   end
 
   @doc """
-  Returns an integer whose text representation is `charlist` in base `base`.
+  Returns an integer whose text representation is `char_list` in base `base`.
 
   Inlined by the compiler.
 
@@ -695,9 +577,9 @@ defmodule List do
       1023
 
   """
-  @spec to_integer(charlist, 2..36) :: integer
-  def to_integer(charlist, base) do
-    :erlang.list_to_integer(charlist, base)
+  @spec to_integer(char_list, 2..36) :: integer
+  def to_integer(char_list, base) do
+    :erlang.list_to_integer(char_list, base)
   end
 
   @doc """
@@ -736,22 +618,10 @@ defmodule List do
   @spec to_string(:unicode.charlist) :: String.t
   def to_string(list) when is_list(list) do
     try do
-      :unicode.characters_to_binary(list)
+       :unicode.characters_to_binary(list)
     rescue
       ArgumentError ->
-        raise ArgumentError, """
-        cannot convert the given list to a string.
-
-        To be converted to a string, a list must contain only:
-
-          * strings
-          * integers representing Unicode codepoints
-          * or a list containing one of these three elements
-
-        Please check the given list or call inspect/1 to get the list representation, got:
-
-        #{inspect list}
-        """
+        raise ArgumentError, "cannot convert list to string. The list must contain only integers, strings or nested such lists; got: #{inspect list}"
     else
       result when is_binary(result) ->
         result
@@ -764,109 +634,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]]
-
-  """
-  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}] | nil
-  def myers_difference(list1, list2) when is_list(list1) and is_list(list2) do
-    path = {0, 0, list1, list2, []}
-    find_script(0, length(list1) + length(list2), [path])
-  end
-
-  defp find_script(envelope, max, _paths) when envelope > max do
-    nil
-  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([{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, Enum.reverse(next_paths)}
-  end
-
-  defp each_diagonal(diag, limit, paths, next_paths) do
-    {path, rest} = proceed_path(diag, limit, paths)
-    with {:cont, path} <- follow_snake(path) do
-      each_diagonal(diag + 2, limit, rest, [path | next_paths])
-    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, 1) > elem(path2, 1) do
-      {move_right(path1), [path2 | rest]}
-    else
-      {move_down(path2), [path2 | rest]}
-    end
-  end
-
-  defp move_right({x, y, list1, [elem | rest], edits}) do
-    {x + 1, y, list1, rest, [{:ins, elem} | edits]}
-  end
-
-  defp move_right({x, y, list1, [], edits}) do
-    {x + 1, y, list1, [], edits}
-  end
-
-  defp move_down({x, y, [elem | rest], list2, edits}) do
-    {x, y + 1, rest, list2, [{:del, elem} | edits]}
-  end
-
-  defp move_down({x, y, [], list2, edits}) do
-    {x, y + 1, [], list2, edits}
-  end
-
-  defp follow_snake({x, y, [elem | rest1], [elem | rest2], edits}) do
-    follow_snake({x + 1, y + 1, rest1, rest2, [{:eq, elem} | edits]})
-  end
-
-  defp follow_snake({_x, _y, [], [], edits}) do
-    {:done, edits}
-  end
-
-  defp follow_snake(path) do
-    {:cont, path}
-  end
-
   ## Helpers
 
   # replace_at
@@ -883,8 +650,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
@@ -897,8 +664,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
@@ -911,30 +678,30 @@ 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
@@ -952,8 +719,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

lib/elixir/lib/list/chars.ex

@@ -1,62 +1,56 @@
 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_char_list` which does the conversion.
 
-  The `to_charlist/1` function automatically imported
-  by `Kernel` invokes this protocol.
+  The `to_char_list` function automatically imported
+  by Kernel invokes this protocol.
   """
 
-  @doc """
-  Converts `term` to a charlist.
-  """
-  @spec to_charlist(t) :: charlist
-  def to_charlist(term)
-
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  Kernel.def to_char_list(term) do
-    __MODULE__.to_charlist(term)
-  end
+  def to_char_list(thing)
 end
 
 defimpl List.Chars, for: Atom do
-  def to_charlist(atom), do: Atom.to_charlist(atom)
+  def to_char_list(atom), do: Atom.to_char_list(atom)
 end
 
 defimpl List.Chars, for: BitString do
   @doc """
-  Returns the given binary `term` converted to a charlist.
+  Returns the given binary converted to a char list.
   """
-  def to_charlist(term) when is_binary(term) do
-    String.to_charlist(term)
+  def to_char_list(thing) when is_binary(thing) do
+    String.to_char_list(thing)
   end
 
-  def to_charlist(term) do
+  def to_char_list(thing) do
     raise Protocol.UndefinedError,
              protocol: @protocol,
-                value: term,
-          description: "cannot convert a bitstring to a charlist"
+                value: thing,
+          description: "cannot convert a bitstring to a char list"
   end
 end
 
 defimpl List.Chars, for: List do
-  # Note that same inlining is used for the rewrite rule.
-  def to_charlist(list), do: list
+  def to_char_list(list), do: list
 end
 
 defimpl List.Chars, for: Integer do
-  def to_charlist(term) do
-    Integer.to_charlist(term)
+  def to_char_list(thing) do
+    Integer.to_char_list(thing)
   end
 end
 
 defimpl List.Chars, for: Float do
-  def to_charlist(term) do
-    :io_lib_format.fwrite_g(term)
+  @digits 20
+  @limit  :math.pow(10, @digits)
+
+  def to_char_list(thing) when thing > @limit do
+    Float.to_char_list(thing, scientific: @digits)
+  end
+
+  def to_char_list(thing) do
+    Float.to_char_list(thing, compact: true, decimals: @digits)
   end
 end

lib/elixir/lib/macro.ex

@@ -1,85 +1,43 @@
 import Kernel, except: [to_string: 1]
 
 defmodule Macro do
-  @moduledoc ~S"""
+  @moduledoc """
   Conveniences for working with macros.
 
   ## Custom Sigils
 
   To create a custom sigil, define a function with the name
   `sigil_{identifier}` that takes two arguments. The first argument will be
-  the string, the second will be a charlist containing any modifiers. If the
-  sigil is lower case (such as `sigil_x`) then the string argument will allow
-  interpolation. If the sigil is upper case (such as `sigil_X`) then the string
-  will not be interpolated.
+  the interpolated string, the second will be a char list containing any
+  modifiers.
 
   Valid modifiers include only lower and upper case letters. Other characters
   will cause a syntax error.
 
   The module containing the custom sigil must be imported before the sigil
   syntax can be used.
-
-  ### Examples
-
-      defmodule MySigils do
-        defmacro sigil_x(term, [?r]) do
-          quote do
-            unquote(term) |> String.reverse()
-          end
-        end
-        defmacro sigil_x(term, _modifiers) do
-          term
-        end
-        defmacro sigil_X(term, [?r]) do
-          quote do
-            unquote(term) |> String.reverse()
-          end
-        end
-        defmacro sigil_X(term, _modifiers) do
-          term
-        end
-      end
-
-      import MySigils
-
-      ~x(with #{"inter" <> "polation"})
-      #=>"with interpolation"
-
-      ~x(with #{"inter" <> "polation"})r
-      #=>"noitalopretni htiw"
-
-      ~X(without #{"interpolation"})
-      #=>"without \#{"interpolation"}"
-
-      ~X(without #{"interpolation"})r
-      #=>"}\"noitalopretni\"{# tuohtiw"
   """
 
   @typedoc "Abstract Syntax Tree (AST)"
-  @type t :: expr | literal
+  @type t :: expr | {t, t} | atom | number | binary | pid | fun | [t]
+  @type expr :: {expr | atom, Keyword.t, atom | [t]}
 
-  @typedoc "Represents expressions in the AST"
-  @type expr :: {expr | atom, keyword, atom | [t]}
-
-  @typedoc "Represents literals in the AST"
-  @type literal :: atom | number | binary | fun | {t, t} | [t]
-
-  binary_ops =
-    [:===, :!==, :==, :!=, :<=, :>=,
-     :&&, :||, :<>, :++, :--, :\\, :::, :<-, :.., :|>, :=~,
-     :<, :>, :->,
-     :+, :-, :*, :/, :=, :|, :.,
-     :and, :or, :when, :in,
-     :~>>, :<<~, :~>, :<~, :<~>, :<|>,
-     :<<<, :>>>, :|||, :&&&, :^^^, :~~~]
+  @binary_ops [:===, :!==,
+    :==, :!=, :<=, :>=,
+    :&&, :||, :<>, :++, :--, :\\, :::, :<-, :.., :|>, :=~,
+    :<, :>, :->,
+    :+, :-, :*, :/, :=, :|, :.,
+    :and, :or, :when, :in,
+    :~>>, :<<~, :~>, :<~, :<~>, :<|>,
+    :<<<, :>>>, :|||, :&&&, :^^^, :~~~]
 
   @doc false
-  defmacro binary_ops, do: unquote(binary_ops)
+  defmacro binary_ops, do: @binary_ops
 
-  unary_ops = [:!, :@, :^, :not, :+, :-, :~~~, :&]
+  @unary_ops [:!, :@, :^, :not, :+, :-, :~~~, :&]
 
   @doc false
-  defmacro unary_ops, do: unquote(unary_ops)
+  defmacro unary_ops, do: @unary_ops
 
   @spec binary_op_props(atom) :: {:left | :right, precedence :: integer}
   defp binary_op_props(o) do
@@ -103,96 +61,10 @@ defmodule Macro do
     end
   end
 
-  # Classifies the given atom into one of the following categories:
-  #
-  #   * :alias - a valid Elixir alias, like Foo, Foo.Bar and so on
-  #
-  #   * :callable - an atom that can be used as a function call after the
-  #     . operator (for example, :<> is callable because Foo.<>(1, 2, 3) is valid
-  #     syntax); this category includes identifiers like :foo
-  #
-  #   * :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")
-  @doc false
-  def classify_identifier(atom) when is_atom(atom) do
-    charlist = Atom.to_charlist(atom)
-
-    cond do
-      atom in [:"%", :"%{}", :"{}", :"<<>>", :"...", :"..", :"."] ->
-        :not_callable
-      atom in unquote(unary_ops) or atom in unquote(binary_ops) ->
-        :callable
-      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
-            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 """
   Breaks a pipeline expression into a list.
 
-  The AST for a pipeline (a sequence of applications of `|>`) is similar to the
-  AST of a sequence of binary operators or function applications: the top-level
-  expression is the right-most `:|>` (which is the last one to be executed), and
-  its left-hand and right-hand sides are its arguments:
-
-      quote do: 100 |> div(5) |> div(2)
-      #=> {:|>, _, [arg1, arg2]}
-
-  In the example above, the `|>` pipe is the right-most pipe; `arg1` is the AST
-  for `100 |> div(5)`, and `arg2` is the AST for `div(2)`.
-
-  It's often useful to have the AST for such a pipeline as a list of function
-  applications. This function does exactly that:
-
-      Macro.unpipe(quote do: 100 |> div(5) |> div(2))
-      #=> [{100, 0}, {{:div, [], [5]}, 0}, {{:div, [], [2]}, 0}]
-
-  We get a list that follows the pipeline directly: first the `100`, then the
-  `div(5)` (more precisely, its AST), then `div(2)`. The `0` as the second
-  element of the tuples is the position of the previous element in the pipeline
-  inside the current function application: `{{:div, [], [5]}, 0}` means that the
-  previous element (`100`) will be inserted as the 0th (first) argument to the
-  `div/2` function, so that the AST for that function will become `{:div, [],
-  [100, 5]}` (`div(100, 5)`).
+  Raises if the pipeline is ill-formed.
   """
   @spec unpipe(Macro.t) :: [Macro.t]
   def unpipe(expr) do
@@ -204,7 +76,7 @@ defmodule Macro do
   end
 
   defp unpipe(other, acc) do
-    [{other, 0} | acc]
+    [{other, 0}|acc]
   end
 
   @doc """
@@ -221,27 +93,12 @@ defmodule Macro do
     raise ArgumentError, bad_pipe(expr, call_args)
   end
 
-  # Without this, `Macro |> Env == Macro.Env`.
-  def pipe(expr, {:__aliases__, _, _} = call_args, _integer) do
-    raise ArgumentError, bad_pipe(expr, call_args)
-  end
-
   def pipe(expr, {call, _, [_, _]} = call_args, _integer)
-      when call in unquote(binary_ops) do
+      when call in unquote(@binary_ops) do
     raise ArgumentError, "cannot pipe #{to_string expr} into #{to_string call_args}, " <>
                          "the #{to_string call} operator can only take two arguments"
   end
 
-  # {:fn, _, _} is what we get when we pipe into an anonymous function without
-  # calling it, e.g., `:foo |> (fn x -> x end)`.
-  def pipe(expr, {:fn, _, _}, _integer) do
-    expr_str = to_string(expr)
-    raise ArgumentError,
-      "cannot pipe #{expr_str} into an anonymous function without" <>
-      " calling the function; use something like (fn ... end).() or" <>
-      " define the anonymous function as a regular private function"
-  end
-
   def pipe(expr, {call, line, atom}, integer) when is_atom(atom) do
     {call, line, List.insert_at([], integer, expr)}
   end
@@ -259,12 +116,6 @@ defmodule Macro do
     "can only pipe into local calls foo(), remote calls Foo.bar() or anonymous functions calls foo.()"
   end
 
-  @doc false
-  def pipe_warning({call, _, _}) when call in unquote(unary_ops) do
-    "piping into a unary operator is deprecated. You could use e.g. Kernel.+(5) instead of +5"
-  end
-  def pipe_warning(_), do: nil
-
   @doc """
   Applies the given function to the node metadata if it contains one.
 
@@ -280,7 +131,7 @@ defmodule Macro do
       {:sample, [], []}
 
   """
-  @spec update_meta(t, (keyword -> keyword)) :: t
+  @spec update_meta(t, (Keyword.t -> Keyword.t)) :: t
   def update_meta(quoted, fun)
 
   def update_meta({left, meta, right}, fun) when is_list(meta) do
@@ -291,21 +142,6 @@ defmodule Macro do
     other
   end
 
-  @doc """
-  Generates AST nodes for a given number of required argument variables using
-  `Macro.var/2`.
-
-  ## Examples
-
-      iex> Macro.generate_arguments(2, __MODULE__)
-      [{:var1, [], __MODULE__}, {:var2, [], __MODULE__}]
-
-  """
-  def generate_arguments(0, _), do: []
-  def generate_arguments(amount, context) when is_integer(amount) and amount > 0 and is_atom(context) do
-    for id <- 1..amount, do: Macro.var(String.to_atom("var" <> Integer.to_string(id)), context)
-  end
-
   @doc """
   Generates an AST node representing the variable given
   by the atoms `var` and `context`.
@@ -314,7 +150,7 @@ defmodule Macro do
 
   In order to build a variable, a context is expected.
   Most of the times, in order to preserve hygiene, the
-  context must be `__MODULE__/0`:
+  context must be `__MODULE__`:
 
       iex> Macro.var(:foo, __MODULE__)
       {:foo, [], __MODULE__}
@@ -332,7 +168,7 @@ defmodule Macro do
   end
 
   @doc """
-  Performs a depth-first traversal of quoted expressions
+  Performs a depth-first, traversal of quoted expressions
   using an accumulator.
   """
   @spec traverse(t, any, (t, any -> {t, any}), (t, any -> {t, any})) :: {t, any}
@@ -341,15 +177,19 @@ defmodule Macro do
     do_traverse(ast, acc, pre, post)
   end
 
-  defp do_traverse({form, meta, args}, acc, pre, post) when is_atom(form) do
-    {args, acc} = do_traverse_args(args, acc, pre, post)
-    post.({form, meta, args}, acc)
-  end
-
   defp do_traverse({form, meta, args}, acc, pre, post) do
-    {form, acc} = pre.(form, acc)
-    {form, acc} = do_traverse(form, acc, pre, post)
-    {args, acc} = do_traverse_args(args, acc, pre, post)
+    unless is_atom(form) do
+      {form, acc} = pre.(form, acc)
+      {form, acc} = do_traverse(form, acc, pre, post)
+    end
+
+    unless is_atom(args) do
+      {args, acc} = Enum.map_reduce(args, acc, fn x, acc ->
+        {x, acc} = pre.(x, acc)
+        do_traverse(x, acc, pre, post)
+      end)
+    end
+
     post.({form, meta, args}, acc)
   end
 
@@ -362,7 +202,10 @@ defmodule Macro do
   end
 
   defp do_traverse(list, acc, pre, post) when is_list(list) do
-    {list, acc} = do_traverse_args(list, acc, pre, post)
+    {list, acc} = Enum.map_reduce(list, acc, fn x, acc ->
+      {x, acc} = pre.(x, acc)
+      do_traverse(x, acc, pre, post)
+    end)
     post.(list, acc)
   end
 
@@ -370,17 +213,6 @@ defmodule Macro do
     post.(x, acc)
   end
 
-  defp do_traverse_args(args, acc, _pre, _post) when is_atom(args) do
-    {args, acc}
-  end
-
-  defp do_traverse_args(args, acc, pre, post) when is_list(args) do
-    Enum.map_reduce(args, acc, fn x, acc ->
-      {x, acc} = pre.(x, acc)
-      do_traverse(x, acc, pre, post)
-    end)
-  end
-
   @doc """
   Performs a depth-first, pre-order traversal of quoted expressions.
   """
@@ -423,19 +255,19 @@ defmodule Macro do
 
   ## Examples
 
-      iex> Macro.decompose_call(quote(do: foo))
+      iex> Macro.decompose_call(quote do: foo)
       {:foo, []}
 
-      iex> Macro.decompose_call(quote(do: foo()))
+      iex> Macro.decompose_call(quote do: foo())
       {:foo, []}
 
-      iex> Macro.decompose_call(quote(do: foo(1, 2, 3)))
+      iex> Macro.decompose_call(quote do: foo(1, 2, 3))
       {:foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote(do: Elixir.M.foo(1, 2, 3)))
+      iex> Macro.decompose_call(quote do: Elixir.M.foo(1, 2, 3))
       {{:__aliases__, [], [:Elixir, :M]}, :foo, [1, 2, 3]}
 
-      iex> Macro.decompose_call(quote(do: 42))
+      iex> Macro.decompose_call(quote do: 42)
       :error
 
   """
@@ -459,7 +291,7 @@ defmodule Macro do
   into a syntax tree.
 
   One may pass `unquote: true` to `escape/2`
-  which leaves `unquote/1` statements unescaped, effectively
+  which leaves `unquote` statements unescaped, effectively
   unquoting the contents on escape.
 
   ## Examples
@@ -474,7 +306,8 @@ defmodule Macro do
       1
 
   """
-  @spec escape(term, keyword) :: Macro.t
+  @spec escape(term) :: Macro.t
+  @spec escape(term, Keyword.t) :: Macro.t
   def escape(expr, opts \\ []) do
     elem(:elixir_quote.escape(expr, Keyword.get(opts, :unquote, false)), 0)
   end
@@ -482,24 +315,8 @@ defmodule Macro do
   @doc """
   Validates the given expressions are valid quoted expressions.
 
-  Checks the `t:Macro.t/0` for the specification of a valid
+  Check the `type:Macro.t` for the specification of a valid
   quoted expression.
-
-  It returns `:ok` if the expression is valid. Otherwise it returns a tuple in the form of
-  `{:error, remainder}` where `remainder` is the invalid part of the quoted expression.
-
-  ## Examples
-
-      iex> Macro.validate({:two_element, :tuple})
-      :ok
-      iex> Macro.validate({:three, :element, :tuple})
-      {:error, {:three, :element, :tuple}}
-
-      iex> Macro.validate([1, 2, 3])
-      :ok
-      iex> Macro.validate([1, 2, 3, {4}])
-      {:error, {4}}
-
   """
   @spec validate(term) :: :ok | {:error, term}
   def validate(expr) do
@@ -537,9 +354,8 @@ defmodule Macro do
   for information on how to customize the escaping map.
 
   In this setup, Elixir will escape the following: `\0`, `\a`, `\b`,
-  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Bytes can be
-  given as hexadecimals via `\xNN` and Unicode Codepoints as
-  `\uNNNN` escapes.
+  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Unicode codepoints
+  can be given as hexadecimals via `\xNN` and `\x{NN...}` escapes.
 
   This function is commonly used on sigil implementations
   (like `~r`, `~s` and others) which receive a raw, unescaped
@@ -582,19 +398,17 @@ defmodule Macro do
       def unescape_map(?t), do: ?\t
       def unescape_map(?v), do: ?\v
       def unescape_map(?x), do: true
-      def unescape_map(?u), do: true
       def unescape_map(e),  do: e
 
-  If the `unescape_map/1` function returns `false`, the char is
-  not escaped and the backslash is kept in the string.
+  If the `unescape_map` function returns `false`. The char is
+  not escaped and `\` is kept in the char list.
 
-  Hexadecimals and Unicode codepoints will be escaped if the map
-  function returns `true` for `?x`. Unicode codepoints if the map
-  function returns `true` for `?u`.
+  Hexadecimals will be escaped if the map function returns `true`
+  for `?x`.
 
   ## Examples
 
-  Using the `unescape_map/1` function defined above is easy:
+  Using the `unescape_map` function defined above is easy:
 
       Macro.unescape_string "example\\n", &unescape_map(&1)
 
@@ -633,24 +447,13 @@ defmodule Macro do
   @doc """
   Converts the given expression to a binary.
 
-  The given `fun` is called for every node in the AST with two arguments: the
-  AST of the node being printed and the string representation of that same
-  node. The return value of this function is used as the final string
-  representation for that AST node.
-
   ## Examples
 
-      iex> Macro.to_string(quote(do: foo.bar(1, 2, 3)))
+      iex> Macro.to_string(quote do: foo.bar(1, 2, 3))
       "foo.bar(1, 2, 3)"
 
-      iex> Macro.to_string(quote(do: 1 + 2), fn
-      ...>   1, _string -> "one"
-      ...>   2, _string -> "two"
-      ...>   _ast, string -> string
-      ...> end)
-      "one + two"
-
   """
+  @spec to_string(Macro.t) :: String.t
   @spec to_string(Macro.t, (Macro.t, String.t -> String.t)) :: String.t
   def to_string(tree, fun \\ fn(_ast, string) -> string end)
 
@@ -731,24 +534,23 @@ defmodule Macro do
   end
 
   # left -> right
-  def to_string([{:->, _, _} | _] = ast, fun) do
+  def to_string([{:->, _, _}|_] = ast, fun) do
     fun.(ast, "(" <> arrow_to_string(ast, fun, true) <> ")")
   end
 
   # left when right
   def to_string({:when, _, [left, right]} = ast, fun) do
-    right =
-      if right != [] and Keyword.keyword?(right) do
-        kw_list_to_string(right, fun)
-      else
-        fun.(ast, op_to_string(right, fun, :when, :right))
-      end
+    if right != [] and Keyword.keyword?(right) do
+      right = kw_list_to_string(right, fun)
+    else
+      right = fun.(ast, op_to_string(right, fun, :when, :right))
+    end
 
     fun.(ast, op_to_string(left, fun, :when, :left) <> " when " <> right)
   end
 
   # Binary ops
-  def to_string({op, _, [left, right]} = ast, fun) when op in unquote(binary_ops) do
+  def to_string({op, _, [left, right]} = ast, fun) when op in unquote(@binary_ops) do
     fun.(ast, op_to_string(left, fun, op, :left) <> " #{op} " <> op_to_string(right, fun, op, :right))
   end
 
@@ -773,14 +575,9 @@ defmodule Macro do
     fun.(ast, "&(" <> to_string(arg, fun) <> ")")
   end
 
-  # left not in right
-  def to_string({:not, _, [{:in, _, [left, right]}]} = ast, fun)  do
-    fun.(ast, to_string(left, fun) <> " not in " <> to_string(right, fun))
-  end
-
   # Unary ops
   def to_string({unary, _, [{binary, _, [_, _]} = arg]} = ast, fun)
-      when unary in unquote(unary_ops) and binary in unquote(binary_ops) do
+      when unary in unquote(@unary_ops) and binary in unquote(@binary_ops) do
     fun.(ast, Atom.to_string(unary) <> "(" <> to_string(arg, fun) <> ")")
   end
 
@@ -788,13 +585,13 @@ defmodule Macro do
     fun.(ast, "not " <> to_string(arg, fun))
   end
 
-  def to_string({op, _, [arg]} = ast, fun) when op in unquote(unary_ops) do
+  def to_string({op, _, [arg]} = ast, fun) when op in unquote(@unary_ops) do
     fun.(ast, Atom.to_string(op) <> to_string(arg, fun))
   end
 
   # Access
   def to_string({{:., _, [Access, :get]}, _, [{op, _, _} = left, right]} = ast, fun)
-      when op in unquote(binary_ops) do
+      when op in unquote(@binary_ops) do
     fun.(ast, "(" <> to_string(left, fun) <> ")" <> to_string([right], fun))
   end
 
@@ -815,7 +612,7 @@ defmodule Macro do
     end
   end
 
-  # Two-element tuples
+  # Two-item tuples
   def to_string({left, right}, fun) do
     to_string({:{}, [], [left, right]}, fun)
   end
@@ -826,9 +623,8 @@ defmodule Macro do
       list == [] ->
         "[]"
       :io_lib.printable_list(list) ->
-        {escaped, _} = Inspect.BitString.escape(IO.chardata_to_string(list), ?')
-        IO.iodata_to_binary [?', escaped, ?']
-      Inspect.List.keyword?(list) ->
+        "'" <> Inspect.BitString.escape(IO.chardata_to_string(list), ?') <> "'"
+      Keyword.keyword?(list) ->
         "[" <> kw_list_to_string(list, fun) <> "]"
       true ->
         "[" <> Enum.map_join(list, ", ", &to_string(&1, fun)) <> "]"
@@ -850,11 +646,11 @@ defmodule Macro do
     to_string(ast, fun)
   end
 
-  defp bitmods_to_string({op, _, [left, right]} = ast, fun, _, _) when op in [:*, :-] do
+  defp bitmods_to_string({:-, _, [left, right]} = ast, fun, _, _) do
     result =
-      bitmods_to_string(left, fun, op, :left) <>
-      Atom.to_string(op) <>
-      bitmods_to_string(right, fun, op, :right)
+      bitmods_to_string(left, fun, :-, :left) <>
+      "-" <>
+      bitmods_to_string(right, fun, :-, :right)
     fun.(ast, result)
   end
 
@@ -863,15 +659,15 @@ defmodule Macro do
   end
 
   # Block keywords
-  kw_keywords = [:do, :catch, :rescue, :after, :else]
+  @kw_keywords [:do, :catch, :rescue, :after, :else]
 
-  defp kw_blocks?([{:do, _} | _] = kw) do
-    Enum.all?(kw, &match?({x, _} when x in unquote(kw_keywords), &1))
+  defp kw_blocks?([_|_] = kw) do
+    Enum.all?(kw, &match?({x, _} when x in unquote(@kw_keywords), &1))
   end
   defp kw_blocks?(_), do: false
 
   # Check if we have an interpolated string.
-  defp interpolated?({:<<>>, _, [_ | _] = parts}) do
+  defp interpolated?({:<<>>, _, [_|_] = parts}) do
     Enum.all?(parts, fn
       {:::, _, [{{:., _, [Kernel, :to_string]}, _, [_]},
                 {:binary, _, _}]} -> true
@@ -921,14 +717,8 @@ defmodule Macro do
 
   defp call_to_string(atom, _fun) when is_atom(atom),
     do: Atom.to_string(atom)
-  defp call_to_string({:., _, [{:&, _, [val]} = arg]}, fun) when not is_integer(val),
-    do: "(" <> module_to_string(arg, fun) <> ")."
-  defp call_to_string({:., _, [{:fn, _, _} = arg]}, fun),
-    do: "(" <> module_to_string(arg, fun) <> ")."
   defp call_to_string({:., _, [arg]}, fun),
     do: module_to_string(arg, fun) <> "."
-  defp call_to_string({:., _, [left, right]}, fun) when is_atom(right),
-    do: module_to_string(left, fun) <> "." <> call_to_string_for_atom(right)
   defp call_to_string({:., _, [left, right]}, fun),
     do: module_to_string(left, fun) <> "." <> call_to_string(right, fun)
   defp call_to_string(other, fun),
@@ -940,27 +730,20 @@ defmodule Macro do
     target <> "(" <> args <> ")"
   end
 
-  defp call_to_string_for_atom(atom) do
-    Inspect.Function.escape_name(atom)
-  end
-
   defp args_to_string(args, fun) do
     {list, last} = :elixir_utils.split_last(args)
 
-    if last != [] and Inspect.List.keyword?(last) do
-      prefix =
-        case list do
-          [] -> ""
-          _  -> Enum.map_join(list, ", ", &to_string(&1, fun)) <> ", "
-        end
-      prefix <> kw_list_to_string(last, fun)
+    if last != [] and Keyword.keyword?(last) do
+      args = Enum.map_join(list, ", ", &to_string(&1, fun))
+      if list != [], do: args = args <> ", "
+      args <> kw_list_to_string(last, fun)
     else
       Enum.map_join(args, ", ", &to_string(&1, fun))
     end
   end
 
   defp kw_blocks_to_string(kw, fun) do
-    Enum.reduce(unquote(kw_keywords), " ", fn(x, acc) ->
+    Enum.reduce(@kw_keywords, " ", fn(x, acc) ->
       case Keyword.has_key?(kw, x) do
         true  -> acc <> kw_block_to_string(x, Keyword.get(kw, x), fun)
         false -> acc
@@ -973,7 +756,7 @@ defmodule Macro do
     Atom.to_string(key) <> "\n  " <> block <> "\n"
   end
 
-  defp block_to_string([{:->, _, _} | _] = block, fun) do
+  defp block_to_string([{:->, _, _}|_] = block, fun) do
     Enum.map_join(block, "\n", fn({:->, _, [left, right]}) ->
       left = comma_join_or_empty_paren(left, fun, false)
       left <> "->\n  " <> adjust_new_lines block_to_string(right, fun), "\n  "
@@ -992,7 +775,7 @@ defmodule Macro do
 
   defp map_to_string(list, fun) do
     cond do
-      Inspect.List.keyword?(list) -> kw_list_to_string(list, fun)
+      Keyword.keyword?(list) -> kw_list_to_string(list, fun)
       true -> map_list_to_string(list, fun)
     end
   end
@@ -1013,22 +796,22 @@ defmodule Macro do
     end)
   end
 
-  defp wrap_in_parenthesis(expr, fun) do
+  defp parenthise(expr, fun) do
     "(" <> to_string(expr, fun) <> ")"
   end
 
-  defp op_to_string({op, _, [_, _]} = expr, fun, parent_op, side) when op in unquote(binary_ops) do
+  defp op_to_string({op, _, [_, _]} = expr, fun, parent_op, side) when op in unquote(@binary_ops) do
     {parent_assoc, parent_prec} = binary_op_props(parent_op)
     {_, prec}                   = binary_op_props(op)
     cond do
       parent_prec < prec -> to_string(expr, fun)
-      parent_prec > prec -> wrap_in_parenthesis(expr, fun)
+      parent_prec > prec -> parenthise(expr, fun)
       true ->
         # parent_prec == prec, so look at associativity.
         if parent_assoc == side do
           to_string(expr, fun)
         else
-          wrap_in_parenthesis(expr, fun)
+          parenthise(expr, fun)
         end
     end
   end
@@ -1065,7 +848,7 @@ defmodule Macro do
 
     * Macros (local or remote)
     * Aliases are expanded (if possible) and return atoms
-    * Compilation environment macros (`__ENV__/0`, `__MODULE__/0` and `__DIR__/0`)
+    * Pseudo-variables (`__ENV__`, `__MODULE__` and `__DIR__`)
     * Module attributes reader (`@foo`)
 
   If the expression cannot be expanded, it returns the expression
@@ -1083,7 +866,7 @@ defmodule Macro do
   Consider the implementation below:
 
       defmacro defmodule_with_length(name, do: block) do
-        length = length(Atom.to_charlist(name))
+        length = length(Atom.to_char_list(name))
 
         quote do
           defmodule unquote(name) do
@@ -1106,7 +889,7 @@ defmodule Macro do
 
   That said, we need to expand the aliases node above to an
   atom, so we can retrieve its length. Expanding the node is
-  not straightforward because we also need to expand the
+  not straight-forward because we also need to expand the
   caller aliases. For example:
 
       alias MyHelpers, as: My
@@ -1123,7 +906,7 @@ defmodule Macro do
 
       defmacro defmodule_with_length(name, do: block) do
         expanded = Macro.expand(name, __CALLER__)
-        length   = length(Atom.to_charlist(expanded))
+        length   = length(Atom.to_char_list(expanded))
 
         quote do
           defmodule unquote(name) do
@@ -1157,7 +940,15 @@ defmodule Macro do
     end
   end
 
-  # Expand compilation environment macros
+  # Expand @ calls
+  defp do_expand_once({:@, _, [{name, _, args}]} = original, env) when is_atom(args) or args == [] do
+    case (module = env.module) && Module.open?(module) do
+      true  -> {escape(Module.get_attribute(module, name)), true}
+      false -> {original, false}
+    end
+  end
+
+  # Expand pseudo-variables
   defp do_expand_once({:__MODULE__, _, atom}, env) when is_atom(atom),
     do: {env.module, true}
   defp do_expand_once({:__DIR__, _, atom}, env) when is_atom(atom),
@@ -1205,7 +996,7 @@ defmodule Macro do
 
       case expand do
         {:ok, receiver, quoted} ->
-          next = :erlang.unique_integer()
+          next = :elixir_counter.next
           {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
         {:ok, _receiver, _name, _args} ->
           {original, false}
@@ -1226,7 +1017,7 @@ defmodule Macro do
 
         case expand do
           {:ok, receiver, quoted} ->
-            next = :erlang.unique_integer()
+            next = :elixir_counter.next
             {:elixir_quote.linify_with_context_counter(0, {receiver, next}, quoted), true}
           :error ->
             {original, false}
@@ -1262,11 +1053,6 @@ defmodule Macro do
   If an atom is given, it is assumed to be an Elixir module,
   so it is converted to a binary and then processed.
 
-  This function was designed to underscore language identifiers/tokens,
-  that's why it belongs to the `Macro` module. Do not use it as a general
-  mechanism for underscoring strings as it does not support Unicode or
-  characters that are not valid in Elixir identifiers.
-
   ## Examples
 
       iex> Macro.underscore "FooBar"
@@ -1287,36 +1073,36 @@ defmodule Macro do
       iex> Macro.camelize "sap_example"
       "SapExample"
 
-      iex> Macro.camelize "hello_10"
-      "Hello10"
-
   """
   def underscore(atom) when is_atom(atom) do
     "Elixir." <> rest = Atom.to_string(atom)
     underscore(rest)
   end
+
+  def underscore(""), do: ""
+
   def underscore(<<h, t::binary>>) do
     <<to_lower_char(h)>> <> do_underscore(t, h)
   end
-  def underscore("") do
-    ""
-  end
-
 
   defp do_underscore(<<h, t, rest::binary>>, _)
-      when (h >= ?A and h <= ?Z) and not (t >= ?A and t <= ?Z) and t != ?. and t != ?_ do
+      when (h >= ?A and h <= ?Z) and not (t >= ?A and t <= ?Z) and t != ?. do
     <<?_, to_lower_char(h), t>> <> do_underscore(rest, t)
   end
+
   defp do_underscore(<<h, t::binary>>, prev)
-      when (h >= ?A and h <= ?Z) and not (prev >= ?A and prev <= ?Z) and prev != ?_ do
+      when (h >= ?A and h <= ?Z) and not (prev >= ?A and prev <= ?Z) do
     <<?_, to_lower_char(h)>> <> do_underscore(t, h)
   end
+
   defp do_underscore(<<?., t::binary>>, _) do
     <<?/>> <> underscore(t)
   end
+
   defp do_underscore(<<h, t::binary>>, _) do
     <<to_lower_char(h)>> <> do_underscore(t, h)
   end
+
   defp do_underscore(<<>>, _) do
     <<>>
   end
@@ -1324,47 +1110,39 @@ defmodule Macro do
   @doc """
   Converts the given string to CamelCase format.
 
-  This function was designed to camelize language identifiers/tokens,
-  that's why it belongs to the `Macro` module. Do not use it as a general
-  mechanism for camelizing strings as it does not support Unicode or
-  characters that are not valid in Elixir identifiers.
-
   ## Examples
 
       iex> Macro.camelize "foo_bar"
       "FooBar"
 
-  If uppercase characters are present, they are not modified in anyway
-  as a mechanism to preserve acronyms:
-
-      iex> Macro.camelize "API.V1"
-      "API.V1"
-      iex> Macro.camelize "API_SPEC"
-      "API_SPEC"
-
   """
   @spec camelize(String.t) :: String.t
   def camelize(string)
 
   def camelize(""),
     do: ""
+
   def camelize(<<?_, t::binary>>),
     do: camelize(t)
+
   def camelize(<<h, t::binary>>),
     do: <<to_upper_char(h)>> <> do_camelize(t)
 
   defp do_camelize(<<?_, ?_, t::binary>>),
     do: do_camelize(<<?_, t::binary >>)
+
   defp do_camelize(<<?_, h, t::binary>>) when h >= ?a and h <= ?z,
     do: <<to_upper_char(h)>> <> do_camelize(t)
-  defp do_camelize(<<?_, h, t::binary>>) when h >= ?0 and h <= ?9,
-    do: <<h>> <> do_camelize(t)
+
   defp do_camelize(<<?_>>),
     do: <<>>
+
   defp do_camelize(<<?/, t::binary>>),
     do: <<?.>> <> camelize(t)
+
   defp do_camelize(<<h, t::binary>>),
     do: <<h>> <> do_camelize(t)
+
   defp do_camelize(<<>>),
     do: <<>>
 

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
@@ -29,27 +29,19 @@ defmodule Macro.Env do
       `nil` if not inside a function
     * `context` - the context of the environment; it can be `nil`
       (default context), inside a guard or inside a match
-    * `aliases` -  a list of two-element tuples, where the first
-      element is the aliased name and the second one the actual name
+    * `aliases` -  a list of two-item tuples, where the first
+      item is the aliased name and the second the actual name
     * `requires` - the list of required modules
     * `functions` - a list of functions imported from each module
     * `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
-    * `lexical_tracker` - PID of the lexical tracker which is responsible for
-      keeping user info
     * `vars` - a list keeping all defined variables as `{var, context}`
-
-  The following fields are private and must not be accessed or relied on:
-
     * `export_vars` - a list keeping all variables to be exported in a
       construct (may be `nil`)
-    * `match_vars` - controls how "new" variables are handled. Inside a
-      match it is a list with all variables in a match. Outside of a match
-      is either `:warn` or `:apply`
-    * `prematch_vars` - a list of variables defined before a match (is
-      `nil` when not inside a match)
-
+    * `lexical_tracker` - PID of the lexical tracker which is responsible for
+      keeping user info
+    * `local` - the module to expand local functions to
   """
 
   @type name_arity :: {atom, arity}
@@ -63,13 +55,10 @@ defmodule Macro.Env do
   @type macros :: [{module, [name_arity]}]
   @type context_modules :: [module]
   @type vars :: [{atom, atom | non_neg_integer}]
-  @type lexical_tracker :: pid | nil
+  @type export_vars :: vars | nil
+  @type lexical_tracker :: pid
   @type local :: atom | nil
 
-  @opaque export_vars :: vars | nil
-  @opaque match_vars :: vars | :warn | :apply
-  @opaque prematch_vars :: vars | nil
-
   @type t :: %{__struct__: __MODULE__,
                module: atom,
                file: file,
@@ -84,9 +73,8 @@ defmodule Macro.Env do
                context_modules: context_modules,
                vars: vars,
                export_vars: export_vars,
-               match_vars: match_vars,
-               prematch_vars: prematch_vars,
-               lexical_tracker: lexical_tracker}
+               lexical_tracker: lexical_tracker,
+               local: local}
 
   def __struct__ do
     %{__struct__: __MODULE__,
@@ -102,21 +90,15 @@ defmodule Macro.Env do
       macro_aliases: [],
       context_modules: [],
       vars: [],
-      lexical_tracker: nil,
       export_vars: nil,
-      match_vars: :warn,
-      prematch_vars: nil}
-  end
-
-  def __struct__(kv) do
-    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
+      lexical_tracker: nil}
   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]

lib/elixir/lib/map.ex

@@ -2,102 +2,18 @@ defmodule Map do
   @moduledoc """
   A set of functions for working with maps.
 
-  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 (`===`). 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 `[]` 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
-
-  The alternative access syntax `map.key` is provided alongside `[]` when the
-  map has a `:key` 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"}
-
-  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
-
-  ## Modules to work with maps
-
-  This module aims to provide functions that perform operations specific to maps
-  (like accessing keys, updating values, and so on). For traversing maps as
-  collections, developers should use the `Enum` module that works across a
-  variety of data types.
-
-  The `Kernel` module also provides a few functions to work with maps: for
-  example, `Kernel.map_size/1` to know the number of key-value pairs in a map or
-  `Kernel.is_map/1` to know if a term is a map.
+  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`.
+  Returns all keys from the map.
 
   ## Examples
 
@@ -109,7 +25,7 @@ defmodule Map do
   defdelegate keys(map), to: :maps
 
   @doc """
-  Returns all values from `map`.
+  Returns all values from the map.
 
   ## Examples
 
@@ -121,10 +37,7 @@ defmodule Map do
   defdelegate values(map), to: :maps
 
   @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.
+  Converts the map to a list.
 
   ## Examples
 
@@ -150,7 +63,7 @@ defmodule Map do
   def new, do: %{}
 
   @doc """
-  Creates a map from an `enumerable`.
+  Creates a map from an enumerable.
 
   Duplicated keys are removed; the latest one prevails.
 
@@ -162,23 +75,15 @@ defmodule Map do
       %{a: 3}
 
   """
-  @spec new(Enumerable.t) :: map
-  def new(enumerable)
-  def new(list) when is_list(list), do: :maps.from_list(list)
-  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
+  @spec new(Enum.t) :: map
+  def new(enumerable) do
+    Enum.reduce(enumerable, %{}, fn {k, v}, acc -> put(acc, k, v) end)
   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.
+  Duplicated entries are removed; the latest one prevails.
 
   ## Examples
 
@@ -186,25 +91,17 @@ 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
-    enumerable
-    |> Enum.to_list
-    |> new_transform(transform, [])
-  end
-
-  defp new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-
-  defp new_transform([item | rest], fun, acc) do
-    new_transform(rest, fun, [fun.(item) | acc])
+  @spec new(Enum.t, (term -> {key, value})) :: map
+  def new(enumerable, transform) do
+    fun = fn el, acc ->
+      {k, v} = transform.(el)
+      put(acc, k, v)
+    end
+    Enum.reduce(enumerable, %{}, fun)
   end
 
   @doc """
-  Returns whether the given `key` exists in the given `map`.
+  Returns whether a given `key` exists in the given `map`.
 
   ## Examples
 
@@ -213,16 +110,14 @@ defmodule Map do
       iex> Map.has_key?(%{a: 1}, :b)
       false
 
-  Inlined by the compiler.
   """
   @spec has_key?(map, key) :: boolean
   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.
+  If the `key` does not exist, returns `:error`.
 
   ## Examples
 
@@ -231,17 +126,14 @@ defmodule Map do
       iex> Map.fetch(%{a: 1}, :b)
       :error
 
-  Inlined by the compiler.
   """
   @spec fetch(map, key) :: {:ok, value} | :error
   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.
+  If `key` does not exist, a `KeyError` is raised.
 
   ## Examples
 
@@ -253,82 +145,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 """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `map`.
-
-  ## Examples
-
-      iex> Map.replace(%{a: 1}, :b, 2)
-      %{a: 1}
-      iex> Map.replace(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-  """
-  @spec replace(map, key, value) :: map
-  def replace(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        put(map, key, value)
-      %{} ->
-        map
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Similar to `replace/3`, but will raise a `KeyError`
-  if the key does not exist in the map.
-
-  ## 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}
-
-  Inlined by the compiler.
-  """
-  @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
 
@@ -345,21 +193,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
 
@@ -367,39 +209,21 @@ 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
-    keys
-    |> Enum.to_list
-    |> 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
+  @spec take(map, [key]) :: map
+  def take(map, keys) do
+    Enum.reduce(keys, new, fn key, acc ->
+      case fetch(map, key) do
+        {:ok, value} -> put(acc, key, value)
+        :error -> acc
       end
-
-    take(rest, map, acc)
+    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, `default` is returned (which is `nil` unless
-  specified otherwise).
+  If `key` does not exist, return the default value
+  (`nil` if no default value).
 
   ## Examples
 
@@ -413,23 +237,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.
@@ -449,18 +269,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`.
+  Puts the given `value` under `key`.
 
   ## Examples
 
@@ -469,17 +285,16 @@ defmodule Map do
       iex> Map.put(%{a: 1, b: 2}, :a, 3)
       %{a: 3, b: 2}
 
-  Inlined by the compiler.
   """
   @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 the map for a specific `key`.
 
-  If the `key` does not exist, returns `map` unchanged.
+  If the `key` does not exist, returns the map unchanged.
 
   ## Examples
 
@@ -488,7 +303,6 @@ defmodule Map do
       iex> Map.delete(%{b: 2}, :a)
       %{b: 2}
 
-  Inlined by the compiler.
   """
   @spec delete(map, key) :: map
   def delete(map, key), do: :maps.remove(key, map)
@@ -496,13 +310,7 @@ 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`).
-
-  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`.
+  All keys in `map2` will be added to `map1`, overriding any existing one.
 
   ## Examples
 
@@ -514,13 +322,10 @@ defmodule Map do
   defdelegate merge(map1, map2), to: :maps
 
   @doc """
-  Merges two maps into one, resolving conflicts through the given `callback`.
+  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 `callback` 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
 
@@ -531,25 +336,16 @@ defmodule Map do
 
   """
   @spec merge(map, map, (key, value, value -> value)) :: map
-  def merge(map1, map2, callback) when is_function(callback, 3) do
-    if map_size(map1) > map_size(map2) do
-      :maps.fold fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> callback.(key, val1, val2) end)
-      end, map1, map2
-    else
-      :maps.fold fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> callback.(key, val2, val1) end)
-      end, 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
 
@@ -560,23 +356,17 @@ 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.
+  Returns and removes all values associated with `key` in the `map`.
 
   ## Examples
 
@@ -590,23 +380,14 @@ defmodule Map do
   """
   @spec pop(map, key, value) :: {value, map}
   def pop(map, key, default \\ nil) do
-    case map do
-      %{^key => value} ->
-        {value, delete(map, key)}
-      %{} ->
-        {default, map}
-      other ->
-        :erlang.error({:badmap, other}, [map, key, default])
+    case fetch(map, key) do
+      {:ok, value} -> {value, delete(map, key)}
+      :error -> {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`.
+  Lazily returns and removes all values associated with `key` in the `map`.
 
   This is useful if the default value is very expensive to calculate or
   generally difficult to setup and teardown again.
@@ -626,20 +407,14 @@ 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.
+  Drops the given keys from the map.
 
   ## Examples
 
@@ -647,31 +422,18 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec drop(map, Enumerable.t) :: map
-  def drop(map, keys)
-
-  def drop(map, keys) when is_map(map) do
-    keys
-    |> 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))
+  @spec drop(map, [key]) :: map
+  def drop(map, keys) do
+    Enum.reduce(keys, map, &delete(&2, &1))
   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.
 
-  Keys for which there are no entries in `map` are ignored.
+  Keys for which there are no entires in the map are ignored.
 
   ## Examples
 
@@ -679,38 +441,22 @@ 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
-    keys
-    |> Enum.to_list
-    |> split([], map)
-  end
-
-  def split(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
-  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)
-    end
+  @spec split(map, [key]) :: {map, map}
+  def split(map, keys) do
+    Enum.reduce(keys, {new, map}, fn key, {inc, exc} = acc ->
+      case fetch(exc, key) do
+        {:ok, value} ->
+          {put(inc, key, value), delete(exc, key)}
+        :error ->
+          acc
+      end
+    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
 
@@ -718,27 +464,31 @@ 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-elements 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`.
+  The returned value is a tuple with the "get" value returned by `fun` and a
+  new map with the updated value under `key`.
 
   ## Examples
 
@@ -752,36 +502,34 @@ defmodule Map do
       ...> end)
       {nil, %{b: "new value!", a: 1}}
 
-      iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
-      {1, %{}}
-
-      iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
-      {nil, %{a: 1}}
-
   """
-  @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)
-
-    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)}"
+  @spec get_and_update(map, key, (value -> {get, value})) :: {get, map} when get: term
+  def get_and_update(%{} = map, key, fun) do
+    current_value = case :maps.find(key, map) do
+      {:ok, value} -> value
+      :error -> nil
     end
+
+    {get, update} = fun.(current_value)
+    {get, :maps.put(key, update, map)}
   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-elements 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
 
-      iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
+      iex> Map.get_and_update!(%{a: 1}, :a, fn(current_value) ->
       ...>   {current_value, "new value!"}
       ...> end)
       {1, %{a: "new value!"}}
@@ -789,34 +537,27 @@ 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}
-
-      iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, %{}}
+      ** (KeyError) key :b not found
 
   """
   @spec get_and_update!(map, key, (value -> {get, value})) :: {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)}"
+  def get_and_update!(%{} = map, key, fun) do
+    case :maps.find(key, map) do
+      {:ok, value} ->
+        {get, update} = fun.(value)
+        {get, :maps.put(key, update, map)}
+      :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.
+  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
 
@@ -833,11 +574,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 """
@@ -855,15 +596,11 @@ 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])
 
+  # TODO: Deprecate by 1.3
+  # TODO: Remove by 1.4
   @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
   def size(map) do
     map_size(map)
   end

lib/elixir/lib/map_set.ex

@@ -1,43 +1,17 @@
 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.
   """
 
+  @opaque t :: %__MODULE__{map: map}
   @type value :: term
-
-  @opaque t(value) :: %__MODULE__{map: %{optional(value) => []}}
-  @type t :: t(term)
-
-  defstruct map: %{}, version: 2
+  defstruct map: %{}
 
   @doc """
   Returns a new set.
@@ -63,20 +37,12 @@ defmodule MapSet do
 
   """
   @spec new(Enum.t) :: t
-  def new(enumerable)
-
-  def new(%__MODULE__{} = map_set), do: map_set
   def new(enumerable) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> new_from_list([])
-
-    %MapSet{map: map}
+    Enum.reduce(enumerable, %MapSet{}, &put(&2, &1))
   end
 
   @doc """
-  Creates a set from an enumerable via the transformation function.
+  Creates a mapset from an enumerable via the transformation function.
 
   ## Examples
 
@@ -84,52 +50,32 @@ 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
-    map =
-      enumerable
-      |> Enum.to_list
-      |> new_from_list_transform(transform, [])
-
-    %MapSet{map: map}
-  end
-
-  defp new_from_list([], acc) do
-    :maps.from_list(acc)
-  end
-
-  defp new_from_list([item | rest], acc) do
-    new_from_list(rest, [{item, []} | acc])
-  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), []} | acc])
+  @spec new(Enum.t, (term -> term)) :: t
+  def new(enumerable, transform) do
+    Enum.reduce(enumerable, %MapSet{}, &put(&2, transform.(&1)))
   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, term) do
+    %{set | map: Map.delete(map, term)}
   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
 
@@ -137,43 +83,16 @@ defmodule MapSet do
       #MapSet<[1]>
 
   """
-  @spec difference(t(val1), t(val2)) :: t(val1) when val1: value, val2: value
-  def difference(map_set1, map_set2)
-
-  # 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)
-
+  @spec difference(t, t) :: t
+  def difference(%MapSet{map: map1}, %MapSet{map: map2}) do
+    map = :maps.fold(fn value, _, acc ->
+      Map.delete(acc, value)
+    end, map1, map2)
     %MapSet{map: map}
   end
 
-  # 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))}
-  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
-    acc =
-      if Map.has_key?(map2, key) do
-        acc
-      else
-        [{key, []} | 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
 
@@ -185,21 +104,16 @@ defmodule MapSet do
   """
   @spec disjoint?(t, t) :: boolean
   def disjoint?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    {map1, map2} = order_by_size(map1, map2)
-
-    map1
-    |> Map.keys
-    |> none_in?(map2)
-  end
-
-  defp none_in?([], _) do
-    true
-  end
-  defp none_in?([key | rest], map2) do
-    case Map.has_key?(map2, key) do
-      true -> false
-      false -> none_in?(rest, map2)
-    end
+    if map_size(map1) > map_size(map2), do: {map1, map2} = {map2, map1}
+    :maps.fold(fn value, _, _ ->
+      if Map.has_key?(map2, value) do
+        throw({:halt, false})
+      else
+        true
+      end
+    end, true, map1)
+  catch
+    {:halt, false} -> false
   end
 
   @doc """
@@ -216,18 +130,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
 
@@ -238,14 +146,21 @@ 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
-    {map1, map2} = order_by_size(map1, map2)
-    %{map_set | map: Map.take(map2, Map.keys(map1))}
+  @spec intersection(t, t) :: t
+  def intersection(%MapSet{map: map1}, %MapSet{map: map2}) do
+    if map_size(map1) > map_size(map2), do: {map1, map2} = {map2, map1}
+    map = :maps.fold(fn value, _, acc ->
+      if Map.has_key?(map2, value) do
+        Map.put(acc, value, true)
+      else
+        acc
+      end
+    end, %{}, map1)
+    %MapSet{map: map}
   end
 
   @doc """
-  Checks if `map_set` contains `value`.
+  Checks if `set` contains `value`.
 
   ## Examples
 
@@ -261,7 +176,7 @@ defmodule MapSet do
   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
 
@@ -271,13 +186,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, [])}
+  @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
 
@@ -291,9 +206,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
 
@@ -306,25 +221,22 @@ defmodule MapSet do
   @spec subset?(t, t) :: boolean
   def subset?(%MapSet{map: map1}, %MapSet{map: map2}) do
     if map_size(map1) <= map_size(map2) do
-      map1
-      |> Map.keys
-      |> map_subset?(map2)
-    else
-      false
-    end
-  end
-
-  defp map_subset?([], _), do: true
-  defp map_subset?([key | rest], map2) do
-    if Map.has_key?(map2, key) do
-      map_subset?(rest, map2)
+      :maps.fold(fn value, _, _ ->
+        if Map.has_key?(map2, value) do
+          true
+        else
+          throw({:halt, false})
+        end
+      end, true, map1)
     else
       false
     end
+  catch
+    {:halt, false} -> false
   end
 
   @doc """
-  Converts `map_set` to a list.
+  Converts `set` to a list.
 
   ## Examples
 
@@ -332,13 +244,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
 
@@ -346,31 +258,22 @@ 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
 
-  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 reduce(map_set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(map_set), acc, fun)
-    def member?(map_set, val), do: {:ok, MapSet.member?(map_set, val)}
-    def count(map_set), do: {:ok, MapSet.size(map_set)}
+    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(original) do
       {original, fn
-        map_set, {:cont, x} -> MapSet.put(map_set, x)
-        map_set, :done -> map_set
+        set, {:cont, x} -> MapSet.put(set, x)
+        set, :done -> set
         _, :halt -> :ok
       end}
     end
@@ -379,8 +282,8 @@ defmodule MapSet do
   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

@@ -65,15 +65,11 @@ defmodule Module.LocalsTracker do
   """
   @spec reachable(ref) :: [local]
   def reachable(ref) do
-    ref
-    |> to_pid()
-    |> :gen_server.call(:digraph, @timeout)
-    |> reachable_from(:local)
-    |> :sets.to_list()
+    reachable_from(:gen_server.call(to_pid(ref), :digraph, @timeout), :local)
   end
 
   defp reachable_from(d, starting) do
-    reduce_reachable(d, starting, :sets.new)
+    :sets.to_list(reduce_reachable(d, starting, :sets.new))
   end
 
   defp reduce_reachable(d, vertex, vertices) do
@@ -87,12 +83,13 @@ defmodule Module.LocalsTracker do
   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)
-    :ets.lookup_element(table, {:elixir, :locals_tracker}, 2)
+    [{_, val}] = :ets.lookup(table, {:elixir, :locals_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__, [], [])
@@ -124,7 +121,7 @@ defmodule Module.LocalsTracker do
     :gen_server.cast(pid, {:add_local, from, to})
   end
 
-  # Adds an import dispatch to the given target.
+  # Adds a 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})
@@ -138,8 +135,8 @@ defmodule Module.LocalsTracker do
 
   # Reattach a previously yanked node
   @doc false
-  def reattach(pid, tuple, kind, function, neighbours) do
-    :gen_server.cast(to_pid(pid), {:reattach, tuple, kind, function, neighbours})
+  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
@@ -147,11 +144,11 @@ defmodule Module.LocalsTracker do
   def collect_imports_conflicts(pid, all_defined) do
     d = :gen_server.call(pid, :digraph, @timeout)
 
-    for {{name, arity}, _, meta, _} <- all_defined,
+    for {name, arity} <- all_defined,
         :digraph.in_neighbours(d, {:import, name, arity}) != [],
         n = :digraph.out_neighbours(d, {:import, name, arity}),
         n != [] do
-      {meta, {n, name, arity}}
+      {n, name, arity}
     end
   end
 
@@ -161,63 +158,73 @@ defmodule Module.LocalsTracker do
   @doc false
   def collect_unused_locals(ref, private) do
     d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    reachable = reachable_from(d, :local)
-    reattached = :digraph.out_neighbours(d, :reattach)
-    {unreachable(reachable, reattached, private), collect_warnings(reachable, private)}
+    {unreachable(d, private), collect_warnings(d, private)}
   end
 
-  defp unreachable(reachable, reattached, private) do
-    for {tuple, kind, _, _} <- private,
-        not reachable?(tuple, kind, reachable, reattached),
-        do: tuple
+  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
+
+    reduce_unreachable(private, [], :sets.from_list(unreachable))
   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 :sets.is_element(tuple, reachable)
-  end
-  defp reachable?(tuple, :defp, reachable, _reattached) do
-    :sets.is_element(tuple, reachable)
-  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 :sets.is_element(tuple, reachable) do
-      acc
+  defp reduce_unreachable([{vertex, callers}|t], acc, unreachable) do
+    if :sets.is_subset(callers, unreachable) do
+      reduce_unreachable(t, [{vertex, callers}|acc], unreachable)
     else
-      [{meta, {:unused_def, tuple, kind}} | acc]
+      reduce_unreachable(acc ++ t, [], :sets.del_element(vertex, unreachable))
     end
   end
 
-  defp collect_warnings({tuple, kind, meta, default}, acc, reachable) when default > 0 do
+  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 collect_warnings({tuple, kind, 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]
+    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
 
-  defp min_reachable_default(max, min, last, name, reachable) when max >= min do
-    case :sets.is_element({name, max}, reachable) do
-      true -> min_reachable_default(max - 1, min, max, name, reachable)
-      false -> min_reachable_default(max - 1, min, last, name, reachable)
-    end
+  @doc false
+  def cache_env(pid, env) do
+    :gen_server.call(pid, {:cache_env, env}, @timeout)
   end
-  defp min_reachable_default(_max, _min, last, _name, _reachable) do
-    last
+
+  @doc false
+  def get_cached_env(pid, ref) do
+    :gen_server.call(pid, {:get_cached_env, ref}, @timeout)
   end
 
   # Stops the gen server
@@ -231,76 +238,79 @@ defmodule Module.LocalsTracker do
   def init([]) do
     d = :digraph.new([:protected])
     :digraph.add_vertex(d, :local)
-    :digraph.add_vertex(d, :reattach)
-    {:ok, d}
-  end
-
-  def handle_call({:yank, local}, _from, d) do
-    out_vertices = :digraph.out_neighbours(d, local)
-    :digraph.del_edges(d, :digraph.out_edges(d, local))
-    {:reply, {[], out_vertices}, d}
-  end
-
-  def handle_call(:digraph, _from, d) do
-    {:reply, d, d}
+    {:ok, {d, []}}
   end
 
   @doc false
-  def handle_info(_msg, d) do
-    {:noreply, d}
+  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_cast({:add_local, from, to}, d) do
+  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, d}
+    {:noreply, state}
   end
 
-  def handle_cast({:add_import, function, module, {name, arity}}, d) do
+  def handle_cast({:add_import, function, module, {name, arity}}, {d, _} = state) do
     handle_import(d, function, module, name, arity)
-    {:noreply, d}
+    {:noreply, state}
   end
 
-  def handle_cast({:add_definition, kind, tuple}, d) do
+  def handle_cast({:add_definition, kind, tuple}, {d, _} = state) do
     handle_add_definition(d, kind, tuple)
-    {:noreply, d}
+    {:noreply, state}
   end
 
-  def handle_cast({:add_defaults, kind, {name, arity}, defaults}, d) do
+  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, arity})
+      handle_add_local(d, {name, i}, {name, i + 1})
     end
-    {:noreply, d}
+    {:noreply, state}
   end
 
-  def handle_cast({:reattach, tuple, kind, function, {in_neigh, out_neigh}}, d) do
-    # Reattach the old function
+  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, function)
+      replace_edge!(d, from, tuple)
     end
 
     for to <- out_neigh do
       :digraph.add_vertex(d, to)
-      replace_edge!(d, function, to)
+      replace_edge!(d, tuple, to)
     end
 
-    # Add the new definition
-    handle_add_definition(d, kind, tuple)
-
-    # Make a call from the old function to the new one
-    if function != tuple do
-      handle_add_local(d, function, tuple)
-    end
-
-    # Finally marked the new one as reattached
-    replace_edge!(d, :reattach, tuple)
-
-    {:noreply, d}
+    {:noreply, state}
   end
 
-  def handle_cast(:stop, d) do
-    {:stop, :normal, d}
+  def handle_cast(:stop, state) do
+    {:stop, :normal, state}
   end
 
   @doc false
@@ -343,7 +353,7 @@ defmodule Module.LocalsTracker do
 
   defp replace_edge!(d, from, to) do
     _ = unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      [:"$e" | _] = :digraph.add_edge(d, from, to)
+      [:"$e"|_] = :digraph.add_edge(d, from, to)
     end
     :ok
   end

lib/elixir/lib/node.ex

@@ -89,9 +89,6 @@ defmodule Node do
 
   For more information, see
   [`:erlang.monitor_node/2`](http://www.erlang.org/doc/man/erlang.html#monitor_node-2).
-  
-  For monitoring status changes of all nodes, see
-  [`:net_kernel.monitor_nodes/3`](http://www.erlang.org/doc/man/net_kernel.html#monitor_nodes-2).
   """
   @spec monitor(t, boolean) :: true
   def monitor(node, flag) do
@@ -104,9 +101,6 @@ defmodule Node do
 
   For more information, see
   [`:erlang.monitor_node/3`](http://www.erlang.org/doc/man/erlang.html#monitor_node-3).
-  
-  For monitoring status changes of all nodes, see
-  [`:net_kernel.monitor_nodes/3`](http://www.erlang.org/doc/man/net_kernel.html#monitor_nodes-2).
   """
   @spec monitor(t, boolean, [:allow_passive_connect]) :: true
   def monitor(node, flag, options) do
@@ -152,7 +146,7 @@ defmodule Node do
   `:ignored` if the local node is not alive.
 
   For more information, see
-  [`:net_kernel.connect_node/1`](http://www.erlang.org/doc/man/net_kernel.html#connect_node-1).
+  [`: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
@@ -160,8 +154,8 @@ 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`](http://www.erlang.org/doc/man/erlang.html#spawn-2).
@@ -174,10 +168,10 @@ 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`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-3).
@@ -190,10 +184,10 @@ 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/4`](http://www.erlang.org/doc/man/erlang.html#spawn-4).
@@ -206,10 +200,10 @@ 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`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-5).
@@ -222,10 +216,10 @@ defmodule Node do
   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.
@@ -236,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.

lib/elixir/lib/option_parser.ex

@@ -4,162 +4,74 @@ defmodule OptionParser do
   """
 
   @type argv    :: [String.t]
-  @type parsed  :: keyword
+  @type parsed  :: Keyword.t
   @type errors  :: [{String.t, String.t | nil}]
-  @type options :: [switches: keyword, strict: keyword, aliases: keyword]
-
-  defmodule ParseError do
-    defexception [:message]
-  end
+  @type options :: [switches: Keyword.t, strict: Keyword.t, aliases: Keyword.t]
 
   @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.
-
-  When parsing, it is common to list switches and their expected types:
-
-      iex> OptionParser.parse(["--debug"], switches: [debug: :boolean])
-      {[debug: true], [], []}
-
-      iex> OptionParser.parse(["--source", "lib"], switches: [source: :string])
-      {[source: "lib"], [], []}
-
-      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                    switches: [source_path: :string, verbose: :boolean])
-      {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
-
-  We will explore the valid switches and operation modes of option parser below.
-
-  ## Options
-
-  The following options are supported:
-
-    * `:switches` or `:strict` - see the "Switch definitions" section below
-    * `:allow_nonexistent_atoms` - see the "Parsing dynamic switches" section below
-    * `:aliases` - see the "Aliases" section below
-
-  ## Switch definitions
-
-  Switches can be specified via one of two options:
-
-    * `:switches` - defines some switches and their types. This function
-      still attempts to parse switches that are not in this list.
-    * `:strict` - defines strict switches. Any switch in `argv` that is not
-      specified in the list is returned in the invalid options 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.
-
-  ### Types
-
-  Switches parsed by `OptionParser` may take zero or one arguments.
-
-  The following switches types take no arguments:
-
-    * `: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
-
-  The following switches take one argument:
-
-    * `:integer` - parses the value as an integer
-    * `:float` - parses the value as a float
-    * `:string` - parses the value as a string
-
-  If a switch can't be parsed according to the given type, 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`.
-
-  To use `:keep` with a type other than `:string`, use a list as the type
-  for the switch. For example: `[foo: [:integer, :keep]]`.
-
-  ### Negation switches
-
-  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 dynamic switches
-
-  `OptionParser` also includes a dynamic mode where it will attempt to parse
-  switches dynamically. Such can be done by not specifying the `:switches` or
-  `:strict` option.
+  ## Examples
 
       iex> OptionParser.parse(["--debug"])
       {[debug: true], [], []}
 
+      iex> OptionParser.parse(["--source", "lib"])
+      {[source: "lib"], [], []}
 
-  Switches followed by a value will be assigned the value, as a string. Switches
-  without an argument, like `--debug` in the examples above, will automatically be
-  set to `true`.
-
-  Since Elixir converts switches to atoms, the dynamic mode will only parse
-  switches that translate to atoms used by the runtime. Therefore, the code below
-  likely won't parse the given option since the `:option_parser_example` atom is
-  never used anywhere:
-
-      OptionParser.parse(["--option-parser-example"])
-      # The :option_parser_example atom is not used anywhere below
-
-  However, the code below does since the `:option_parser_example` atom is used
-  at some point later (or earlier) on:
-
-      {opts, _, _} = OptionParser.parse(["--option-parser-example"])
-      opts[:option_parser_example]
-
-  In other words, when using dynamic mode, 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.
-  Such option is useful when you are building command-line applications that
-  receive dynamically-named arguments but must be used with care on long-running
-  systems.
+      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"])
+      {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
 
+  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` in the examples above, will
-  automatically be set to `true`.
+  Switches without an argument, like `--debug` will automatically
+  be set to `true`.
 
-  ## Aliases
+  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.
 
-  A set of aliases can be specified in the `:aliases` option:
+  ## Switch Definitions
 
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
-      {[debug: true], [], []}
+  Often it is better to explicitly list the known
+  switches and their formats. The switches can be specified via two
+  alternative options:
 
-  ## Examples
+    * `:switches` - defines some switches. An attempt is still made to parse
+      switches that do not appear in the list.
 
-  Here are some examples of working with different types and modifiers:
+    * `:strict` - the switches are strict. Any switch that is not specified
+      in the list is returned in the invalid options list.
+
+  Note that you should only supply the `:switches` or `:strict` option. If you
+  supply both, an error will be raised.
+
+  For each switch, the following types are supported:
+
+    * `:boolean` - marks the given switch as a boolean. Boolean switches
+      never consume the following value unless it is `true` or
+      `false`.
+    * `:integer` - parses the switch as an integer.
+    * `:float`   - parses the switch as a float.
+    * `:string`  - returns the switch as a string.
+
+  If a switch can't be parsed, it is returned in the invalid options list.
+
+  The following extra "types" are supported:
+
+    * `:keep` - keeps duplicated items in the list instead of overriding them.
+
+  Note: if you want to use `:keep` with a non-string type, use a list, e.g.
+  `[foo: [:integer, :keep]]`.
+
+  Examples:
 
       iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
       {[unlock: true], ["path/to/file"], []}
@@ -174,12 +86,6 @@ defmodule OptionParser do
       iex> OptionParser.parse(["--limit", "xyz"], strict: [limit: :integer])
       {[], [], [{"--limit", "xyz"}]}
 
-      iex> OptionParser.parse(["--verbose"], switches: [verbose: :count])
-      {[verbose: 1], [], []}
-
-      iex> OptionParser.parse(["-v", "-v"], aliases: [v: :verbose], strict: [verbose: :count])
-      {[verbose: 2], [], []}
-
       iex> OptionParser.parse(["--unknown", "xyz"], strict: [])
       {[], ["xyz"], [{"--unknown", nil}]}
 
@@ -190,47 +96,25 @@ 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)
-  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:
-
-    * `parsed` is the list of parsed switches (same as in `parse/2`)
-    * `rest` is the list of arguments (same as in `parse/2`)
-
-  ## 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"
-
-      iex> OptionParser.parse!(["--unknown", "xyz"], strict: [])
-      ** (OptionParser.ParseError) 1 error found!
-      --unknown : Unknown option
-
-      iex> OptionParser.parse!(["-l", "xyz", "-f", "bar"],
-      ...>                     switches: [limit: :integer, foo: :integer], aliases: [l: :limit, f: :foo])
-      ** (OptionParser.ParseError) 2 errors found!
-      -l : Expected type integer, got "xyz"
-      -f : Expected type integer, got "bar"
-
-  """
-  @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}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
+    do_parse(argv, compile_config(opts), [], [], [], true)
   end
 
   @doc """
@@ -241,81 +125,45 @@ 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)
-  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:
-
-    * `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`)
-
-  ## 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])
-      ** (OptionParser.ParseError) 1 error found!
-      --number : Expected type integer, got "lib"
-
-      iex> OptionParser.parse_head!(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
-      ...>                          strict: [verbose: :integer, source: :integer])
-      ** (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
-  def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse_head(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
+    do_parse(argv, compile_config(opts), [], [], [], false)
   end
 
   defp do_parse([], _config, opts, args, invalid, _all?) 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
+        # the option exist and it was successfully parsed
         kinds = List.wrap Keyword.get(switches, option)
-        new_opts = store_option(opts, option, value, kinds)
+        new_opts = do_store_option(opts, option, value, kinds)
         do_parse(rest, config, new_opts, args, invalid, all?)
 
       {:invalid, option, value, rest} ->
         # the option exist but it has wrong value
-        do_parse(rest, config, opts, args, [{option, value} | invalid], all?)
+        do_parse(rest, config, opts, args, [{option, value}|invalid], all?)
 
       {:undefined, option, _value, rest} ->
         # the option does not exist (for strict cases)
-        do_parse(rest, config, opts, args, [{option, nil} | invalid], all?)
+        do_parse(rest, config, opts, args, [{option, nil}|invalid], all?)
 
-      {:error, ["--" | rest]} ->
+      {: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?)
+          do_parse(rest, config, opts, [arg|args], invalid, all?)
         else
           {Enum.reverse(opts), Enum.reverse(args, remaining_args), Enum.reverse(invalid)}
         end
@@ -326,21 +174,22 @@ 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)
 
-    * `{:error, rest}` - there are no switches at the head of the given `argv`
-
+    * `{: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} |
@@ -348,132 +197,79 @@ defmodule OptionParser do
         {: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
+  defp next(["-" <> option|rest], aliases, switches, strict) do
     {option, value} = split_option(option)
-    tagged = tag_option(option, config)
-    next_tagged(tagged, value, "--" <> option, rest, config)
-  end
+    opt_name_bin = "-" <> option
+    tagged = tag_option(option, switches, aliases)
 
-  # Handles -a, -abc, -abc=something
-  defp next_with_config(["-" <> option | rest] = argv, config) do
-    %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
-    {option, value} = split_option(option)
-    original = "-" <> option
-
-    cond do
-      is_nil(value) and negative_number?(original) ->
-        {:error, argv}
-      String.contains?(option, ["-", "_"]) ->
-        {:undefined, original, value, rest}
-      String.length(option) > 1 ->
-        key = get_option_key(option, allow_nonexistent_atoms?)
-        option_key = aliases[key]
-        if key && option_key do
-          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(option, value) ++ rest, config)
-        end
-      true ->
-        # We have a regular one-letter alias here
-        tagged = tag_oneletter_alias(option, config)
-        next_tagged(tagged, value, original, rest, config)
-    end
-  end
-
-  defp next_with_config(argv, _config) do
-    {:error, argv}
-  end
-
-  defp next_tagged(tagged, value, original, rest, %{switches: switches, strict?: strict?}) do
-    if strict? and not option_defined?(tagged, switches) do
-      {:undefined, original, value, rest}
+    if strict and not option_defined?(tagged, switches) do
+      {:undefined, opt_name_bin, value, rest}
     else
-      {option, kinds, value} = normalize_option(tagged, value, switches)
-      {value, kinds, rest} = normalize_value(value, kinds, rest, strict?)
+      {opt_name, 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}
+        {:ok, new_value} -> {:ok, opt_name, new_value, rest}
+        :invalid         -> {:invalid, opt_name_bin, value, rest}
       end
     end
   end
 
+  defp next(argv, _aliases, _switches, _strict) do
+    {:error, argv}
+  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"])
       ["--foo-bar", "baz"]
+
       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, 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
 
@@ -482,11 +278,10 @@ 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
-    do_split(String.trim_leading(string, " "), "", [], nil)
+  def split(string) do
+    do_split(strip_leading_spaces(string), "", [], nil)
   end
 
   # If we have an escaped quote, simply remove the escape
@@ -507,7 +302,7 @@ defmodule OptionParser do
 
   # If we have space and we are outside of a quote, start new segment
   defp do_split(<<?\s, t::binary>>, buffer, acc, nil),
-    do: do_split(String.trim_leading(t, " "), "", [buffer | acc], nil)
+    do: do_split(strip_leading_spaces(t), "", [buffer|acc], nil)
 
   # All other characters are moved to buffer
   defp do_split(<<h, t::binary>>, buffer, acc, quote) do
@@ -519,119 +314,88 @@ defmodule OptionParser do
     do: Enum.reverse(acc)
 
   defp do_split(<<>>, buffer, acc, nil),
-    do: Enum.reverse([buffer | acc])
+    do: Enum.reverse([buffer|acc])
 
   # Otherwise raise
   defp do_split(<<>>, _, _acc, marker) do
     raise "argv string did not terminate properly, a #{<<marker>>} was opened but never closed"
   end
 
+  defp strip_leading_spaces(" " <> t), do: strip_leading_spaces(t)
+  defp strip_leading_spaces(t), do: t
+
   ## Helpers
 
-  defp build_config(opts) do
-    {switches, strict?} = cond do
+  defp compile_config(opts) do
+    aliases = opts[:aliases] || []
+
+    {switches, strict} = cond do
       opts[:switches] && opts[:strict] ->
         raise ArgumentError, ":switches and :strict cannot be given together"
-      switches = opts[:switches] ->
-        {switches, false}
-      strict = opts[:strict] ->
-        {strict, true}
+      s = opts[:switches] ->
+        {s, false}
+      s = opts[:strict] ->
+        {s, true}
       true ->
         {[], 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
-    {invalid?, value} =
-      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
-            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
+    {is_invalid, value} = cond do
+      :invalid in kinds ->
+        {true, value}
+      :boolean in kinds ->
+        case value do
+          t when t in [true, "true"] -> {nil, true}
+          f when f in [false, "false"] -> {nil, false}
+          _ -> {true, value}
+        end
+      :integer in kinds ->
+        case Integer.parse(value) do
+          {value, ""} -> {nil, value}
+          _ -> {true, value}
+        end
+      :float in kinds ->
+        case Float.parse(value) do
+          {value, ""} -> {nil, value}
+          _ -> {true, value}
+        end
+      true ->
+        {nil, value}
+    end
 
-    if invalid? do
+    if is_invalid do
       :invalid
     else
       {:ok, value}
     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)
       :keep in kinds ->
-        [{option, value} | dict]
+        [{option, value}|dict]
       true ->
-        [{option, value} | Keyword.delete(dict, option)]
+        [{option, value}|Keyword.delete(dict, option)]
     end
   end
 
-  defp tag_option("no-" <> option = original, %{switches: switches, allow_nonexistent_atoms?: allow_nonexistent_atoms?}) do
-    cond do
-      (negated = get_option_key(option, allow_nonexistent_atoms?)) && :boolean in List.wrap(switches[negated]) ->
-        {:negated, negated}
-      option_key = get_option_key(original, allow_nonexistent_atoms?) ->
-        {:default, option_key}
-      true ->
-        :unknown
-    end
+  defp tag_option(<<?-, option::binary>>, switches, _aliases) do
+    get_negated(option, switches)
   end
 
-  defp tag_option(option, %{allow_nonexistent_atoms?: allow_nonexistent_atoms?}) do
-    if option_key = get_option_key(option, 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 tag_oneletter_alias(alias, %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?}) when is_binary(alias) do
-    if option_key = aliases[to_existing_key(alias, allow_nonexistent_atoms?)] do
-      {:default, option_key}
-    else
-      :unknown
-    end
-  end
-
-  defp expand_multiletter_alias(letters, value) when is_binary(letters) do
-    {last, expanded} =
-      letters
-      |> String.codepoints()
-      |> Enum.map(&("-" <> &1))
-      |> List.pop_at(-1)
-    expanded ++ [last <> if(value, do: "=" <> value, else: "")]
-  end
-
   defp option_defined?(:unknown, _switches) do
     false
   end
@@ -660,33 +424,30 @@ defmodule OptionParser do
     {option, List.wrap(switches[option]), value}
   end
 
-  defp normalize_value(nil, kinds, t, strict?) do
+  defp normalize_value(nil, kinds, t, strict) do
+    nil_or_true = if strict, do: nil, else: true
     cond do
       :boolean in kinds ->
         {true, kinds, t}
-      :count in kinds ->
-        {1, kinds, t}
       value_in_tail?(t) ->
-        [h | t] = t
+        [h|t] = t
         {h, kinds, t}
-      kinds == [] and strict? ->
-        {nil, kinds, t}
       kinds == [] ->
-        {true, kinds, t}
+        {nil_or_true, kinds, t}
       true ->
         {nil, [:invalid], t}
     end
   end
 
-  defp normalize_value(value, kinds, t, _strict?) 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?(["-" <> arg | _]), do: negative_number?("-" <> arg)
-  defp value_in_tail?([]),               do: false
-  defp value_in_tail?(_),                do: true
+  defp value_in_tail?(["-"|_]),       do: true
+  defp value_in_tail?(["- " <> _|_]), do: true
+  defp value_in_tail?(["-" <> _|_]),  do: false
+  defp value_in_tail?([]),            do: false
+  defp value_in_tail?(_),             do: true
 
   defp split_option(option) do
     case :binary.split(option, "=") do
@@ -695,66 +456,40 @@ defmodule OptionParser do
     end
   end
 
-  defp to_underscore(option),
-    do: to_underscore(option, <<>>)
-  defp to_underscore("_" <> _rest, _acc),
-    do: nil
+  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
-    if string = to_underscore(option) do
-      to_existing_key(string, allow_nonexistent_atoms?)
+  defp to_underscore(<<>>, acc), do: acc
+
+  defp get_option(option) do
+    if str = to_underscore(option) do
+      String.to_atom(str)
     end
   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_negated("no-" <> rest = original, switches) do
+    cond do
+      (negated = get_option(rest)) && :boolean in List.wrap(switches[negated]) ->
+        {:negated, negated}
+      option = get_option(original) ->
+        {:default, option}
+      true ->
+        :unknown
     end
   end
 
-  defp negative_number?(arg) do
-    match?({_, ""}, Float.parse(arg))
-  end
-
-  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))
-  end
-
-  defp format_error({option, nil}, opts, types) do
-    if type = get_type(option, opts, types) do
-      "#{option} : Missing argument of type #{type}"
+  defp get_negated(rest, _switches) do
+    if option = get_option(rest) do
+      {:default, option}
     else
-      "#{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}"
-  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?)
-
-    if option_key = opts[:aliases][key] do
-      types[option_key]
-    else
-      types[key]
+      :unknown
     end
   end
 end

lib/elixir/lib/path.ex

@@ -3,24 +3,23 @@ defmodule Path do
   This module provides conveniences for manipulating or
   retrieving file system paths.
 
-  The functions in this module may receive a chardata as
+  The functions in this module may receive a char data as
   argument (i.e. a string or a list of characters / string)
   and will always return a string (encoded in UTF-8).
 
   The majority of the functions in this module do not
   interact with the file system, except for a few functions
-  that require it (like `wildcard/2` and `expand/1`).
+  that require it (like `wildcard/1` 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,12 +27,12 @@ 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
@@ -42,10 +41,8 @@ defmodule Path do
   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 `~`.
@@ -72,15 +69,15 @@ 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),
+  defp absname_vr([<<x, ?:>>|rest], [<<x, _::binary>>|_], relative),
     do: absname(absname_join(rest), relative)
 
   # Relative to current directory on another drive.
-  defp absname_vr([<<x, ?:>> | name], _, _relative) do
+  defp absname_vr([<<x, ?:>>|name], _, _relative) do
     cwd =
       case :file.get_cwd([x, ?:]) do
         {:ok, dir}  -> IO.chardata_to_string(dir)
@@ -90,8 +87,8 @@ defmodule Path do
   end
 
   # Joins a list
-  defp absname_join([name1, name2 | rest]), do:
-    absname_join([absname_join(name1, name2) | rest])
+  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())
 
@@ -100,31 +97,31 @@ defmodule Path do
     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)
+    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(<<?/, 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)
+    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)
+    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)
+    do_absname_join(rest, relativename, [char|result], os_type)
 
-  defp reverse_maybe_remove_dir_sep([?/, ?:, letter], :win32), do:
+  defp reverse_maybe_remove_dirsep([?/, ?:, letter], :win32), do:
     [letter, ?:, ?/]
-  defp reverse_maybe_remove_dir_sep([?/], _), do:
+  defp reverse_maybe_remove_dirsep([?/], _), do:
     [?/]
-  defp reverse_maybe_remove_dir_sep([?/ | name], _), do:
+  defp reverse_maybe_remove_dirsep([?/|name], _), do:
     :lists.reverse(name)
-  defp reverse_maybe_remove_dir_sep(name, _), do:
+  defp reverse_maybe_remove_dirsep(name, _), do:
     :lists.reverse(name)
 
   @doc """
@@ -134,7 +131,7 @@ defmodule Path do
   ## Examples
 
       Path.expand("/foo/bar/../bar")
-      #=> "/foo/bar"
+      "/foo/bar"
 
   """
   @spec expand(t) :: binary
@@ -144,11 +141,10 @@ defmodule Path do
 
   @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.
@@ -173,9 +169,7 @@ defmodule Path do
   @doc """
   Returns the path type.
 
-  ## Examples
-
-  ### Unix
+  ## Unix examples
 
       Path.type("/")                #=> :absolute
       Path.type("/usr/local/bin")   #=> :absolute
@@ -183,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
@@ -192,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"
@@ -235,49 +225,46 @@ defmodule Path do
     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([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([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([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.
@@ -303,11 +290,11 @@ defmodule Path do
     relative_to(split(path), split(from), path)
   end
 
-  defp relative_to([h | t1], [h | t2], original) do
+  defp relative_to([h|t1], [h|t2], original) do
     relative_to(t1, t2, original)
   end
 
-  defp relative_to([_ | _] = l1, [], _original) do
+  defp relative_to([_|_] = l1, [], _original) do
     join(l1)
   end
 
@@ -317,10 +304,8 @@ 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
@@ -348,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
 
@@ -372,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 """
@@ -380,19 +363,15 @@ defmodule Path do
 
   ## Examples
 
-      iex> Path.dirname("/foo/bar.ex")
-      "/foo"
-
-      iex> Path.dirname("/foo/bar/baz.ex")
-      "/foo/bar"
-
-      iex> Path.dirname("/foo/bar/")
-      "/foo/bar"
+      Path.dirname("/foo/bar.ex")
+      #=> "/foo"
+      Path.dirname("/foo/bar/baz.ex")
+      #=> "/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 """
@@ -409,7 +388,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 """
@@ -426,14 +405,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
 
@@ -446,14 +423,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
 
@@ -467,41 +444,38 @@ defmodule Path do
       "/foo/bar"
 
   """
-  @spec join(nonempty_list(t)) :: binary
-  def join([name1, name2 | rest]), do:
-    join([join(name1, name2) | rest])
+  @spec join([t]) :: binary
+  def join([name1, name2|rest]), do:
+    join([join(name1, name2)|rest])
   def join([name]), do:
-    IO.chardata_to_string(name)
+    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"
-
   """
   @spec join(t, t) :: binary
   def join(left, right) do
     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(left, right, os_type), do: remove_dir_sep(left, os_type) <> "/" <> relative(right, os_type)
+  defp do_join(left, right, os_type), do: remove_dirsep(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)
@@ -537,7 +511,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
@@ -547,8 +521,13 @@ 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 ->
@@ -567,7 +546,7 @@ 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 certain
@@ -582,18 +561,14 @@ defmodule Path do
     * `**` - two adjacent `*`'s used as a single pattern will match all
       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.
+    * `[char1, char2, ...]` - matches any of the characters listed; two
+      characters separated by a hyphen will match a range of characters
 
-    * `{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.
+    * `{item1, item2, ...}` - matches one of the alternatives
 
   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 `.` unless `match_dot: true` is given in `opts`.
@@ -601,7 +576,7 @@ defmodule Path do
   ## 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")
@@ -611,23 +586,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
@@ -647,7 +620,7 @@ defmodule Path do
   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
       {"/" <> _, _} ->
@@ -656,8 +629,6 @@ defmodule Path do
     end
   end
 
-  # expand_dot the given path by expanding "..", "." and "~".
-
   defp expand_dot(<<"/", rest::binary>>),
     do: "/" <> do_expand_dot(rest)
   defp expand_dot(<<letter, ":/", rest::binary>>) when letter in ?a..?z,
@@ -668,17 +639,17 @@ defmodule Path do
   defp do_expand_dot(path),
     do: do_expand_dot(:binary.split(path, "/", [:global]), [])
 
-  defp do_expand_dot([".." | t], [_, _ | acc]),
+  defp do_expand_dot([".."|t], [_, _|acc]),
     do: do_expand_dot(t, acc)
-  defp do_expand_dot([".." | t], []),
+  defp do_expand_dot([".."|t], []),
     do: do_expand_dot(t, [])
-  defp do_expand_dot(["." | t], acc),
+  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([h|t], acc),
+    do: do_expand_dot(t, ["/", h|acc])
   defp do_expand_dot([], []),
     do: ""
-  defp do_expand_dot([], ["/" | acc]),
+  defp do_expand_dot([], ["/"|acc]),
     do: IO.iodata_to_binary(:lists.reverse(acc))
 
   defp major_os_type do

lib/elixir/lib/port.ex

@@ -1,187 +1,32 @@
 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 oops"}, [:binary])
-      iex> flush()
-      {#Port<0.1444>, {:data, "oops\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 preferrable 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`.
-
-  ### spawn_driver
-
-  Spawn driver is used to start Port Drivers, which are programs written in
-  C that implements a specific communication protocols and are dynamically
-  linked to the Erlang VM. Port drivers are an advanced topic and one of the
-  mechanisms for integrating C code, alongside NIFs. For more information,
-  [please check the Erlang docs](http://erlang.org/doc/reference_manual/ports.html).
-
-  ### 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 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} |
+  @type name :: {:spawn, char_list | binary} |
+                {:spawn_driver, char_list | binary} |
+                {:spawn_executable, char_list | 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`](http://www.erlang.org/doc/man/erlang.html#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.
   """
@@ -227,7 +72,36 @@ 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.
+
+  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.
+  """
+  @spec control(port, integer, iodata) :: iodata | binary
+  def control(port, operation, data) do
+    :erlang.port_control(port, operation, data)
+  end
+
+  @doc """
+  Makes a synchronous call to the `port` and returns its reply as a term.
+
+  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).
   """
@@ -236,7 +110,8 @@ defmodule Port do
   end
 
   @doc """
-  Returns information about the `port` or `nil` if the port is closed.
+  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).
   """
@@ -255,7 +130,9 @@ defmodule Port do
   end
 
   @doc """
-  Returns a list of all ports in the current node.
+  Returns a list of the ports for the current node.
+
+  For more information, see [`:erlang.ports/0`](http://www.erlang.org/doc/man/erlang.html#ports-0).
 
   Inlined by the compiler.
   """

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`
@@ -15,31 +15,32 @@ defmodule Process do
   """
 
   @doc """
-  Tells whether the given process is alive.
+  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.
+  `pid` must refer to a process at the local node.
 
   Inlined by the compiler.
   """
   @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.
+  Returns all key-values in the 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`.
   """
+  @spec get(term) :: term
   @spec get(term, default :: term) :: term
   def get(key, default \\ nil) do
     case :erlang.get(key) do
@@ -56,30 +57,25 @@ 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"
+  Stores the given key-value in the process dictionary.
 
+  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
@@ -87,19 +83,7 @@ defmodule Process do
   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
-
+  Deletes the given `key` from the dictionary.
   """
   @spec delete(term) :: term | nil
   def delete(key) do
@@ -107,232 +91,122 @@ defmodule Process do
   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`:
+  The following behaviour applies if reason is any term except `:normal` or `:kill`:
 
-    1. If `pid` is not trapping exits, `pid` will exit with the given
-       `reason`.
+    1. If pid is not trapping exits, pid will exit with the given reason.
 
-    2. If `pid` is trapping exits, the exit signal is transformed into a
-       message `{:EXIT, from, reason}` and delivered to the message queue
-       of `pid`.
+    2. If pid is trapping exits, the exit signal is transformed into a 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
-
-  @doc """
-  Sleeps the current process for the given `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.
-
-  **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
-  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.
-
-  In other words, **do not**:
-
-      Task.start_link fn ->
-        do_something()
-        ...
-      end
-
-      # Wait until work is done
-      Process.sleep(2000)
-
-  But **do**:
-
-      parent = self()
-      Task.start_link fn ->
-        do_something()
-        send parent, :work_is_done
-        ...
-      end
-
-      receive do
-        :work_is_done -> :ok
-      after
-        30_000 -> :timeout # Optional timeout
-      end
-
-  For cases like the one above, `Task.async/1` and `Task.await/2` are
-  preferred.
-
-  Similarly, if you are waiting for a process to terminate,
-  monitor that process instead of sleeping. **Do not**:
-
-      Task.start_link fn ->
-        ...
-      end
-
-      # Wait until task terminates
-      Process.sleep(2000)
-
-  Instead **do**:
-
-      {:ok, pid} =
-        Task.start_link fn ->
-          ...
-        end
-
-      ref = Process.monitor(pid)
-      receive do
-        {:DOWN, ^ref, _, _, _} -> :task_is_down
-      after
-        30_000 -> :timeout # Optional timeout
-      end
-
-  """
-  @spec sleep(timeout) :: :ok
-  def sleep(timeout)
-      when is_integer(timeout) and timeout >= 0
-      when timeout == :infinity do
-    receive after: (timeout -> :ok)
+  def exit(pid, reason) do
+    :erlang.exit(pid, reason)
   end
 
   @doc """
   Sends a message to the given process.
 
-  ## Options
+  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.
 
-    * `: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
 
-  Inlined by the compiler.
   """
-  @spec send(dest, msg, [option]) :: :ok | :noconnect | :nosuspend
-        when dest: pid | port | atom | {atom, node},
-             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 an integer, it represents the time in milli-seconds
+  left until the timer will expire.
 
-  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.
-
-  ## 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`.
+  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 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`.
 
-  When the result is an integer, it represents the time in milliseconds
+  When the result is an integer, it represents the time in milli-seconds
   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} |
@@ -341,29 +215,32 @@ defmodule Process do
   @type spawn_opts :: [spawn_opt]
 
   @doc """
-  Spawns the given function according to the given options.
+  Spawns the given module and function 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.
 
-  More options are available; for the comprehensive list of available options
+  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 module and function 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`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-4).
@@ -371,22 +248,13 @@ defmodule Process do
   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.
+  The calling process starts monitoring the item given.
+  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.
@@ -400,129 +268,89 @@ defmodule Process do
   end
 
   @doc """
-  Demonitors the monitor identifies 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`](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`](http://www.erlang.org/doc/man/erlang.html#processes-0) for more info.
-
-  Inlined by the compiler.
   """
-  @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).
-
-  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`.
+  Creates a link between the calling process and another process
+  (or port) `pid`, if there is not such a link already.
 
   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).
-
-  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`.
+  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
 
   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 the #{pid_or_port pid_or_port} because it belongs to another node"
-      :erlang.error ArgumentError.exception(message), [pid_or_port, name]
-    :error, :badarg ->
-      message = "could not register the #{pid_or_port pid_or_port} with " <>
-                "name #{inspect name}. Or it is not alive, or 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
 
-  defp pid_or_port(pid) when is_pid(pid), do: "pid #{inspect pid}"
-  defp pid_or_port(port) when is_port(port), do: "port #{inspect port}"
+  @doc """
+  Associates the name with a pid or a port identifier. `name`, which must
+  be an atom, can 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`).
+  """
+  @spec register(pid | port, atom) :: true
+  def register(pid, name) when not name in [nil, false, true] do
+    :erlang.register(name, pid)
+  end
 
   @doc """
-  Removes the registered `name`, associated with a PID
-  or a port identifier.
+  Removes the registered name, associated 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.
+  See [`:erlang.unregister/1`](http://www.erlang.org/doc/man/erlang.html#unregister-1) for more info.
   """
   @spec unregister(atom) :: true
-  defdelegate unregister(name), to: :erlang
+  def unregister(name) do
+    :erlang.unregister(name)
+  end
 
   @doc """
-  Returns the PID or port identifier registered under `name` or `nil` if the
-  name is not registered.
+  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.
   """
@@ -532,20 +360,16 @@ defmodule Process do
   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
@@ -554,74 +378,53 @@ 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
-
-  @typep heap_size :: non_neg_integer |
-                      %{size: non_neg_integer, kill: boolean, error_logger: boolean}
-
-  @typep priority_level :: :low | :normal | :high | :max
+  @spec registered :: [atom]
+  def registered do
+    :erlang.registered()
+  end
 
+  @typep process_flag :: :trap_exit | :error_handler | :min_heap_size |
+                         :min_bin_vheap_size | :priority | :save_calls |
+                         :sensitive
   @doc """
-  Sets the given `flag` to `value` for the calling process.
-
-  Returns the old value of `flag`.
+  Sets certain flags for the process which calls this function.
+  Returns the old value of the flag.
 
   See [`:erlang.process_flag/2`](http://www.erlang.org/doc/man/erlang.html#process_flag-2) for more info.
-
-  Note that `flag` values `:max_heap_size` and `:message_queue_data` are only available since OTP 19.
-
-  Inlined by the compiler.
   """
-  @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..10_000) :: 0..10_000
-  @spec flag(:sensitive, boolean) :: boolean
-  @spec flag(:trap_exit, boolean) :: boolean
-  defdelegate flag(flag, value), to: :erlang, as: :process_flag
+  @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 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`.
+  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`.
 
   See [`:erlang.process_flag/3`](http://www.erlang.org/doc/man/erlang.html#process_flag-3) for more info.
-
-  Inlined by the compiler.
   """
-  @spec flag(pid, :save_calls, 0..10_000) :: 0..10_000
-  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
+  Returns information about the process identified by `pid` or `nil` if the process
   is not alive.
-
   Use this only for debugging information.
 
   See [`:erlang.process_info/1`](http://www.erlang.org/doc/man/erlang.html#process_info-1) for more info.
   """
-  @spec info(pid) :: keyword
+  @spec info(pid) :: Keyword.t
   def info(pid) do
     nillify :erlang.process_info(pid)
   end
 
   @doc """
-  Returns information about the process identified by `pid`,
-  or returns `nil` if the process is not alive.
+  Returns information about the process identified by `pid`
+  or `nil` if the process is not alive.
 
   See [`:erlang.process_info/2`](http://www.erlang.org/doc/man/erlang.html#process_info-2) for more info.
   """
@@ -641,9 +444,7 @@ defmodule Process do
   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.
@@ -653,7 +454,9 @@ defmodule Process do
   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

lib/elixir/lib/protocol.ex

@@ -23,15 +23,15 @@ defmodule Protocol do
                            :lists.seq(2, arity))
     type_args = [quote(do: t) | type_args]
 
-    call_args = :lists.map(fn pos -> Macro.var(String.to_atom("var" <> Integer.to_string(pos)), __MODULE__) end,
+    call_args = :lists.map(fn i -> {String.to_atom(<<?x, i + 64>>), [], __MODULE__} end,
                            :lists.seq(2, arity))
-    call_args = [quote(do: term) | call_args]
+    call_args = [quote(do: t) | call_args]
 
     quote do
       name  = unquote(name)
       arity = unquote(arity)
 
-      @functions [{name, arity} | @functions]
+      @functions [{name, arity}|@functions]
 
       # Generate a fake definition with the user
       # signature that will be used by docs
@@ -39,7 +39,7 @@ defmodule Protocol do
 
       # 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,
@@ -50,13 +50,13 @@ defmodule Protocol do
   end
 
   defmacro def(_) do
-    raise ArgumentError, "invalid arguments for def inside defprotocol"
+    raise ArgumentError, "invalid args for def inside defprotocol"
   end
 
   @doc """
   Checks if the given module is loaded and is protocol.
 
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
+  Returns `:ok` if so, otherwise raises ArgumentError.
   """
   @spec assert_protocol!(module) :: :ok | no_return
   def assert_protocol!(module) do
@@ -83,7 +83,7 @@ defmodule Protocol do
   Checks if the given module is loaded and is an implementation
   of the given protocol.
 
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
+  Returns `:ok` if so, otherwise raises ArgumentError.
   """
   @spec assert_impl!(module, module) :: :ok | no_return
   def assert_impl!(protocol, base) do
@@ -129,8 +129,8 @@ defmodule Protocol do
   @doc """
   Extracts all protocols from the given paths.
 
-  The paths can be either a charlist or a string. Internally
-  they are worked on as charlists, so passing them as lists
+  The paths can be either a char list or a string. Internally
+  they are worked on as char lists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the protocols.
@@ -144,7 +144,7 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_protocols([charlist | String.t]) :: [atom]
+  @spec extract_protocols([char_list | String.t]) :: [atom]
   def extract_protocols(paths) do
     extract_matching_by_attribute paths, 'Elixir.',
       fn module, attributes ->
@@ -159,8 +159,8 @@ defmodule Protocol do
   Extracts all types implemented for the given protocol from
   the given paths.
 
-  The paths can be either a charlist or a string. Internally
-  they are worked on as charlists, so passing them as lists
+  The paths can be either a char list or a string. Internally
+  they are worked on as char lists, so passing them as lists
   avoid extra conversion.
 
   Does not load any of the implementations.
@@ -174,12 +174,12 @@ defmodule Protocol do
       true
 
   """
-  @spec extract_impls(module, [charlist | String.t]) :: [atom]
+  @spec extract_impls(module, [char_list | String.t]) :: [atom]
   def extract_impls(protocol, paths) when is_atom(protocol) do
-    prefix = Atom.to_charlist(protocol) ++ '.'
+    prefix = Atom.to_char_list(protocol) ++ '.'
     extract_matching_by_attribute paths, prefix, fn
       _mod, attributes ->
-        case attributes[:protocol_impl] do
+        case attributes[:impl] do
           [protocol: ^protocol, for: for] -> for
           _ -> nil
         end
@@ -200,7 +200,7 @@ defmodule Protocol do
     end
   end
 
-  defp list_dir(path), do: list_dir(to_charlist(path))
+  defp list_dir(path), do: list_dir(to_char_list(path))
 
   defp extract_from_file(path, file, prefix, callback) do
     if :lists.prefix(prefix, file) and :filename.extension(file) == '.beam' do
@@ -254,22 +254,23 @@ defmodule Protocol do
     {: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, 'ExDc']
+    chunk_ids = [:abstract_code, :attributes, @docs_chunk]
     opts = [:allow_missing_chunks]
     case :beam_lib.chunks(beam_file(protocol), chunk_ids, opts) do
       {:ok, {^protocol, [{:abstract_code, {_raw, abstract_code}},
                          {:attributes, attributes},
-                         {:compile_info, compile_info},
-                         {'ExDc', docs}]}} ->
+                         {@docs_chunk, docs}]}} ->
         case attributes[:protocol] do
           [fallback_to_any: any] ->
-            {:ok, {protocol, any, abstract_code}, {compile_info, docs}}
+            {:ok, {protocol, any, abstract_code, docs}}
           _ ->
             {:error, :not_a_protocol}
         end
@@ -287,81 +288,58 @@ defmodule Protocol do
 
   # Change the debug information to the optimized
   # impl_for/1 dispatch version.
-  defp change_debug_info({protocol, any, code}, types) do
+  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
+    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}
+      {: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, l, [{:atom, _, :impls}], [], [{:atom, _, _}]} ->
-        {:clause, l, [{:atom, 0, :impls}], [], [{:tuple, 0, [{:atom, 0, :consolidated}, abstract_types]}]}
       {:clause, _, _, _, _} = c ->
         c
     end, clauses)
 
-    change_impl_for(tail, protocol, types, structs, true,
-                    [{:function, line, :__protocol__, 1, clauses} | 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__(),
+    clauses = for {guard, mod} <- builtin,
                   mod in types,
                   do: builtin_clause_for(mod, guard, protocol, line)
 
-    clauses = [struct_clause_for(line) | clauses] ++
+    clauses = [struct_clause_for(line)|clauses] ++
               [fallback_clause_for(fallback, protocol, line)]
 
-    change_impl_for(tail, protocol, types, structs, protocol?,
-                    [{:function, line, :impl_for, 1, clauses} | 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)]
 
-    change_impl_for(tail, protocol, types, structs, protocol?,
-                    [{:function, line, :struct_impl_for, 1, clauses} | 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?}]}, _]} ->
-          {:type, line, :fun,
-           [{:type, line, :product, [{:atom, 0, :consolidated?}]},
-            {:atom, 0, true}]}
-        {:type, line, :fun, [{:type, _, :product, [{:atom, _, :impls}]}, _]} ->
-          {:type, line, :fun,
-           [{:type, line, :product, [{:atom, 0, :impls}]},
-            {:type, 0, :tuple,
-             [{:atom, 0, :consolidated},
-              {:type, 0, :list, [{:type, 0, :module, []}]}]}]}
-        other -> other
-      end
-    end
-    change_impl_for(tail, protocol, types, structs, protocol?, [{:attribute, line, :spec, {{:__protocol__, 1}, new_specs}} | 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
@@ -391,9 +369,9 @@ defmodule Protocol do
           [{: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
@@ -406,15 +384,13 @@ defmodule Protocol do
   end
 
   # Finally compile the module and emit its bytecode.
-  defp compile(protocol, code, {compile_info, docs}) do
-    opts = Keyword.take(compile_info, [:source])
-    opts = if Code.compiler_options[:debug_info], do: [:debug_info | opts], else: opts
-    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return | opts])
-    {:ok,
-      case docs do
-        :missing_chunk -> binary
-        _ -> :elixir_erl.add_beam_chunks(binary, [{"ExDc", docs}])
-      end}
+  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])
+    unless docs == :missing_chunk do
+      binary = :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
+    end
+    {:ok, binary}
   end
 
   ## Definition callbacks
@@ -443,15 +419,14 @@ 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
-      @doc false
-      @spec impl_for(term) :: atom | nil
+    quote bind_quoted: [builtin: builtin] do
+      @spec impl_for(term) :: atom() | nil
       Kernel.def impl_for(data)
 
       # Define the implementation for structs.
@@ -462,39 +437,28 @@ defmodule Protocol do
         struct_impl_for(struct)
       end
 
-      # Define the implementation for built-ins
+      # 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 impl_for?(unquote(target)) do
             true  -> unquote(target).__impl__(:target)
-            false -> any_impl_for()
+            false -> any_impl_for
           end
         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
-        any_impl_for()
-      end
-
-      @doc false
-      @spec impl_for!(term) :: atom | no_return
+      @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)
+        Kernel.defp any_impl_for, do: __MODULE__.Any.__impl__(:target)
       else
-        Kernel.defp any_impl_for(), do: nil
+        Kernel.defp any_impl_for, do: nil
       end
 
       # Internal handler for Structs
@@ -502,7 +466,7 @@ defmodule Protocol do
         target = Module.concat(__MODULE__, struct)
         case impl_for?(target) do
           true  -> target.__impl__(:target)
-          false -> any_impl_for()
+          false -> any_impl_for
         end
       end
 
@@ -527,20 +491,18 @@ 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
+      @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
-      Kernel.def __protocol__(:impls), do: :not_consolidated
     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__([h|t]),
+    do: [:lists.foldl(&{:|, [], [&1, &2]}, h, t), quote(do: ...)]
 
   @doc false
   def __impl__(protocol, opts) do
@@ -571,8 +533,15 @@ defmodule Protocol do
       for      = unquote(for)
       name     = Module.concat(protocol, for)
 
-      Protocol.assert_protocol!(protocol)
-      Protocol.__ensure_defimpl__(protocol, for, __ENV__)
+      # TODO: Remove this by 1.3
+      if Atom.to_string(protocol) =~ "Elixir.Access" do
+        :elixir_errors.warn __ENV__.line, __ENV__.file,
+          "implementation of the Access protocol is deprecated. For customization of " <>
+          "the data[key] syntax, please implement the Access behaviour in your struct"
+      else
+        Protocol.assert_protocol!(protocol)
+        Protocol.__ensure_defimpl__(protocol, for, __ENV__)
+      end
 
       defmodule name do
         @behaviour protocol
@@ -581,8 +550,8 @@ defmodule Protocol do
 
         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
@@ -626,8 +595,8 @@ defmodule Protocol do
           apply(mod, fun, args)
         else
           Module.create(Module.concat(protocol, for), quote do
-            Module.register_attribute(__MODULE__, :protocol_impl, persist: true)
-            @protocol_impl [protocol: unquote(protocol), for: unquote(for)]
+            Module.register_attribute(__MODULE__, :impl, persist: true)
+            @impl [protocol: unquote(protocol), for: unquote(for)]
 
             @doc false
             @spec __impl__(:target) :: unquote(impl)
@@ -658,9 +627,9 @@ defmodule Protocol do
 
     specs = Module.get_attribute(module, :spec)
     found =
-      :lists.map(fn {:spec, expr, pos} ->
+      :lists.map(fn {:spec, expr, caller} ->
         if Kernel.Typespec.spec_to_signature(expr) == signature do
-          Module.store_typespec(module, :callback, {:callback, expr, pos})
+          Kernel.Typespec.define_spec(:callback, expr, caller)
           true
         end
       end, specs)
@@ -670,8 +639,7 @@ defmodule Protocol do
 
   ## Helpers
 
-  @doc false
-  def __builtin__ do
+  defp builtin do
     [is_tuple: Tuple,
      is_atom: Atom,
      is_list: List,

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,29 +21,13 @@ 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:
-
-      iex> range = 1..10
-      1..10
-      iex> Enum.reduce(range, 0, fn i, acc -> i * i + acc end)
-      385
-      iex> Enum.count(range)
-      10
-      iex> Enum.member?(range, 11)
-      false
-      iex> Enum.member?(range, 8)
-      true
-
   """
 
   defstruct first: nil, last: nil
 
-  @type t :: %Range{first: integer, last: integer}
+  @type t :: %Range{}
   @type t(first, last) :: %Range{first: first, last: last}
 
-
   @doc """
   Creates a new range.
   """
@@ -59,7 +43,9 @@ defmodule Range do
   end
 
   @doc """
-  Returns `true` if the given `term` is a valid range.
+  Returns `true` if the given `term` is a range.
+
+  It does not check if the range is valid.
 
   ## Examples
 
@@ -70,38 +56,39 @@ defmodule Range do
       false
 
   """
-  @spec range?(term) :: boolean
+  @spec range?(%Range{}) :: true
+  @spec range?(term) :: false
   def range?(term)
-  def range?(first..last) when is_integer(first) and is_integer(last), do: true
+  def range?(%Range{}), do: true
   def range?(_), do: false
 end
 
 defimpl Enumerable, for: Range do
-  def reduce(first..last, acc, fun) do
-    reduce(first, last, acc, fun, _up? = last >= first)
+  def reduce(first .. last, acc, fun) do
+    reduce(first, last, acc, fun, last >= first)
   end
 
-  defp reduce(_x, _y, {:halt, acc}, _fun, _up?) do
+  defp reduce(_x, _y, {:halt, acc}, _fun, _up) do
     {:halted, acc}
   end
 
-  defp reduce(x, y, {:suspend, acc}, fun, up?) do
-    {:suspended, acc, &reduce(x, y, &1, fun, up?)}
+  defp reduce(x, y, {:suspend, acc}, fun, up) do
+    {:suspended, acc, &reduce(x, y, &1, fun, up)}
   end
 
-  defp reduce(x, y, {:cont, acc}, fun, _up? = true) when x <= y do
-    reduce(x + 1, y, fun.(x, 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(x, y, {:cont, acc}, fun, _up? = false) when x >= y do
-    reduce(x - 1, y, fun.(x, 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
     {:done, acc}
   end
 
-  def member?(first..last, value) when is_integer(value) do
+  def member?(first .. last, value) when is_integer(value) do
     if first <= last do
       {:ok, first <= value and value <= last}
     else
@@ -109,11 +96,11 @@ defimpl Enumerable, for: Range do
     end
   end
 
-  def member?(_.._, _value) do
+  def member?(_ .. _, _value) do
     {:ok, false}
   end
 
-  def count(first..last) do
+  def count(first .. last) do
     if first <= last do
       {:ok, last - first + 1}
     else
@@ -125,7 +112,7 @@ end
 defimpl Inspect, for: Range do
   import Inspect.Algebra
 
-  def inspect(first..last, opts) do
+  def inspect(first .. last, opts) do
     concat [to_doc(first, opts), "..", to_doc(last, opts)]
   end
 end

lib/elixir/lib/record.ex

@@ -1,6 +1,6 @@
 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:
 
@@ -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,34 +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.
-
-  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
 
@@ -71,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
@@ -79,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.
 
@@ -121,14 +85,14 @@ defmodule Record 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)
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and :erlang.element(1, unquote(data)) == 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
+          is_tuple(result) and tuple_size(result) > 0
+            and :erlang.element(1, result) == unquote(kind)
         end
     end
   end
@@ -152,39 +116,24 @@ defmodule Record 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))
+          is_tuple(unquote(data)) and tuple_size(unquote(data)) > 0
+            and is_atom(:erlang.element(1, unquote(data)))
         end
       false ->
         quote do
           result = unquote(data)
-          is_tuple(result) and tuple_size(result) > 0 and is_atom(elem(result, 0))
+          is_tuple(result) and tuple_size(result) > 0
+            and is_atom(:erlang.element(1, result))
         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
 
@@ -194,10 +143,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}
@@ -209,10 +155,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]
 
@@ -224,24 +166,23 @@ 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,
@@ -255,7 +196,6 @@ 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
@@ -294,14 +234,14 @@ defmodule Record do
   @doc false
   def __fields__(type, fields) do
     :lists.map(fn
-      {key, value} when is_atom(key) ->
+      {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}
@@ -312,61 +252,62 @@ defmodule Record do
 
   # 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 ->
-        msg = "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
       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) ->
         new_fields =
-          case Keyword.fetch(each_keyword, field) do
-            {:ok, value} -> value
-            :error when in_match -> {:_, [], nil}
-            :error -> Macro.escape(default)
+          case Keyword.has_key?(each_keyword, field) do
+            true  -> Keyword.get(each_keyword, field)
+            false ->
+              case in_match do
+                true  -> {:_, [], nil}
+                false -> Macro.escape(default)
+              end
           end
 
         {new_fields, Keyword.delete(each_keyword, field)}
@@ -374,21 +315,19 @@ 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) ->
       index = find_index(fields, key, 0)
       if index do
@@ -396,62 +335,41 @@ defmodule Record 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
 
   # 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
 
-  defp find_index([{k, _} | _], k, i), do: i + 2
-  defp find_index([{_, _} | t], k, i), do: find_index(t, k, i + 1)
+  defp find_index([{k, _}|_], k, i), do: i + 2
+  defp find_index([{_, _}|t], k, i), do: find_index(t, k, i + 1)
   defp find_index([], _k, _i), do: nil
 
   # Returns a keyword list of the record
   @doc false
-  def __keyword__(tag, fields, record) do
-    if is_record(record, tag) do
-      [_tag | values] = Tuple.to_list(record)
-      case join_keyword(fields, values, []) do
-        kv when is_list(kv) ->
-          kv
-        expected_fields ->
-          msg = "expected argument to be a #{inspect tag} record with #{expected_fields} fields, got: #{inspect record}"
-          raise ArgumentError, msg
-      end
+  def __keyword__(atom, fields, record) do
+    if is_record(record, atom) do
+      [_tag|values] = Tuple.to_list(record)
+      join_keyword(fields, values, [])
     else
-      msg = "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([{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) # expected fields
-
-  defp apply_underscore(fields, keyword) do
-    case Keyword.fetch(keyword, :_) do
-      {:ok, default} ->
-        fields
-        |> Enum.map(fn {k, _} -> {k, default} end)
-        |> Keyword.merge(keyword)
-        |> Keyword.delete(:_)
-      :error ->
-        keyword
-    end
-  end
 end

lib/elixir/lib/record/extractor.ex

@@ -27,7 +27,7 @@ defmodule Record.Extractor do
 
   # Find file using the same lookup as the *include* attribute from Erlang modules.
   defp from_file(file) do
-    file = String.to_charlist(file)
+    file = String.to_char_list(file)
     case :code.where_is_file(file) do
       :non_existing -> file
       realfile -> realfile
@@ -36,12 +36,12 @@ 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))
+    [app|path] = :filename.split(String.to_char_list(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])
+        :filename.join([libpath|path])
     end
   end
 

lib/elixir/lib/regex.ex

@@ -1,60 +1,33 @@
 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.html#sigil_r/2) or [`~R`](Kernel.html#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 expressions that matches foo anywhere in the string
       ~r/foo/
 
-      # A regular expression with case insensitive and Unicode options
+      # 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, endianess,
-  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 recomend precompiling Elixir projects using
-  the 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
 
   The modifiers available when creating a Regex are:
 
-    * `unicode` (u) - enables Unicode specific patterns like `\p` and change
-      modifiers like `\w`, `\W`, `\s` and friends to also match on Unicode.
-      It expects valid Unicode strings to be given on match
+    * `unicode` (u) - enables unicode specific patterns like `\p` and change
+      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
@@ -97,7 +70,7 @@ defmodule Regex do
       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}
 
@@ -118,7 +91,7 @@ defmodule Regex do
 
   The given options can either be a binary with the characters
   representing the same regex options given to the `~r` sigil,
-  or a list of options, as expected by the Erlang's `:re` module.
+  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.
@@ -133,84 +106,40 @@ defmodule Regex do
 
   """
   @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
+  @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.
-  """
-  @spec recompile(t) :: t
-  def recompile(%Regex{} = regex) do
-    version = version()
-
-    # We use Map.get/3 by choice to support old regexes versions.
-    case Map.get(regex, :re_version, :error) do
-      ^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.
-  """
-  @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.
-  """
-  # TODO: No longer check for function_exported? on OTP 20+.
-  def version do
-    if function_exported?(:re, :version, 0) do
-      :re.version()
-    else
-      "8.33 2013-05-29"
+      {:error, {reason, at}} -> raise Regex.CompileError, message: "#{reason} at position #{at}"
     end
   end
 
@@ -244,7 +173,8 @@ defmodule Regex do
       false
 
   """
-  @spec regex?(any) :: boolean
+  @spec regex?(t) :: true
+  @spec regex?(any) :: false
   def regex?(term)
   def regex?(%Regex{}), do: true
   def regex?(_), do: false
@@ -255,7 +185,7 @@ defmodule Regex do
 
   ## Options
 
-    * `:return`  - sets to `:index` to return indexes. 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.
 
@@ -361,7 +291,7 @@ defmodule Regex do
     names
   end
 
-  @doc ~S"""
+  @doc """
   Same as `run/3`, but scans the target several times collecting all
   matches of the regular expression.
 
@@ -370,7 +300,7 @@ defmodule Regex do
 
   ## Options
 
-    * `:return`  - sets to `:index` to return indexes. 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.
 
@@ -385,9 +315,6 @@ defmodule Regex do
       iex> Regex.scan(~r/e/, "abcd")
       []
 
-      iex> Regex.scan(~r/\p{Sc}/u, "$, £, and €")
-      [["$"], ["£"], ["€"]]
-
   """
   @spec scan(t, String.t, [term]) :: [[String.t]]
   def scan(regex, string, options \\ [])
@@ -421,35 +348,26 @@ defmodule Regex do
       order. Defaults to `:first` which means captures inside the regex do not
       affect the splitting process.
 
-    * `:include_captures` - when `true`, includes in the result the matches of
-      the regular expression. Defaults to `false`.
-
   ## 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")
+      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)
-      ["Eli", "x", "ir"]
-
-      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]
   def split(regex, string, options \\ [])
@@ -468,8 +386,7 @@ defmodule Regex do
       {:match, matches} ->
         do_split(matches, string, 0,
                  parts_to_index(Keyword.get(opts, :parts, :infinity)),
-                 Keyword.get(opts, :trim, false),
-                 Keyword.get(opts, :include_captures, false))
+                 Keyword.get(opts, :trim, false))
       :match ->
         [string]
       :nomatch ->
@@ -480,47 +397,30 @@ defmodule Regex do
   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,
+  defp do_split(_, string, offset, _counter, true) when byte_size(string) <= offset,
     do: []
 
-  defp do_split(_, string, offset, 1, _trim, _with_captures),
+  defp do_split(_, string, offset, 1, _trim),
     do: [binary_part(string, offset, byte_size(string) - offset)]
 
-  defp do_split([], string, offset, _counter, _trim, _with_captures),
+  defp do_split([], string, offset, _counter, _trim),
     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)
+  defp do_split([[{pos, _}|h]|t], string, offset, counter, trim) when pos - offset < 0,
+    do: do_split([h|t], string, offset, counter, trim)
 
-  defp do_split([[] | t], string, offset, counter, trim, with_captures),
-    do: do_split(t, string, offset, counter, trim, with_captures)
+  defp do_split([[]|t], string, offset, counter, trim),
+    do: do_split(t, string, offset, counter, trim)
 
-  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, true) do
-    new_offset = pos + length
-    keep = pos - offset
-
-    if keep == 0 and length == 0 do
-      do_split([h | t], string, new_offset, counter, trim, true)
-    else
-      <<_::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
-
-  defp do_split([[{pos, length} | h] | t], string, offset, counter, trim, false) do
+  defp do_split([[{pos, length}|h]|t], string, offset, counter, trim) do
     new_offset = pos + length
     keep = pos - offset
 
     if keep == 0 and (length == 0 or trim) do
-      do_split([h | t], string, new_offset, counter, trim, false)
+      do_split([h|t], string, new_offset, counter, trim)
     else
       <<_::binary-size(offset), part::binary-size(keep), _::binary>> = string
-      [part | do_split([h | t], string, new_offset, counter - 1, trim, false)]
+      [part|do_split([h|t], string, new_offset, counter - 1, trim)]
     end
   end
 
@@ -530,10 +430,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
@@ -585,13 +483,13 @@ defmodule Regex do
 
   defp do_replace(%Regex{re_pattern: compiled}, string, replacement, options) do
     opts = if Keyword.get(options, :global) != false, do: [:global], else: []
-    opts = [{:capture, :all, :index} | opts]
+    opts = [{:capture, :all, :index}|opts]
 
     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
+      {:match, [mlist|t]} when is_list(mlist) ->
+        apply_list(string, replacement, [mlist|t]) |> IO.iodata_to_binary
       {:match, slist} ->
         apply_list(string, replacement, [slist]) |> IO.iodata_to_binary
     end
@@ -611,7 +509,7 @@ defmodule Regex do
 
   defp precompile_replacement(<<?\\, x, rest::binary>>) when x in ?0..?9 do
     {ns, rest} = pick_int(rest)
-    [List.to_integer([x | ns]) | precompile_replacement(rest)]
+    [List.to_integer([x|ns]) | precompile_replacement(rest)]
   end
 
   defp precompile_replacement(<<x, rest::binary>>) do
@@ -625,7 +523,7 @@ defmodule Regex do
 
   defp pick_int(<<x, rest::binary>>) when x in ?0..?9 do
     {found, rest} = pick_int(rest)
-    {[x | found], rest}
+    {[x|found], rest}
   end
 
   defp pick_int(bin) do
@@ -693,13 +591,16 @@ defmodule Regex do
   end
 
   defp get_indexes(string, [], arity) do
-    ["" | get_indexes(string, [], arity - 1)]
+    [""|get_indexes(string, [], arity - 1)]
   end
 
-  defp get_indexes(string, [h | t], arity) do
-    [get_index(string, h) | get_indexes(string, t, arity - 1)]
+  defp get_indexes(string, [h|t], arity) 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.
 
@@ -714,31 +615,7 @@ defmodule Regex do
   """
   @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
@@ -755,19 +632,17 @@ defmodule Regex do
 
   # Private Helpers
 
-  defp translate_options(<<?u, t::binary>>, acc), do: translate_options(t, [:unicode, :ucp | acc])
-  defp translate_options(<<?i, t::binary>>, acc), do: translate_options(t, [:caseless | acc])
-  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(<<?m, t::binary>>, acc), do: translate_options(t, [:multiline | acc])
+  defp translate_options(<<?u, t::binary>>, acc), do: translate_options(t, [:unicode, :ucp|acc])
+  defp translate_options(<<?i, t::binary>>, acc), do: translate_options(t, [:caseless|acc])
+  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(<<?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"
-    translate_options(t, [:ungreedy | acc])
-  end
+  # TODO: Deprecate by 1.2
+  # TODO: Remove by 2.0
+  defp translate_options(<<?r, t::binary>>, acc), do: translate_options(t, [:ungreedy|acc])
 
   defp translate_options(<<>>, acc), do: acc
   defp translate_options(rest, _acc), do: {:error, rest}

lib/elixir/lib/set.ex

@@ -6,11 +6,23 @@ defmodule Set do
   """
 
   @type value :: any
-  @type values :: [value]
+  @type values :: [ value ]
   @type t :: map
 
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
+  # TODO: Remove callbacks on 1.3
+  # TODO: Deprecate every function on 1.3
+  @callback new :: t
+  @callback delete(t, value) :: t
+  @callback difference(t, t) :: t
+  @callback disjoint?(t, t) :: boolean
+  @callback equal?(t, t) :: boolean
+  @callback intersection(t, t) :: t
+  @callback member?(t, value) :: boolean
+  @callback put(t, value) :: t
+  @callback size(t) :: non_neg_integer
+  @callback subset?(t, t) :: boolean
+  @callback to_list(t) :: list()
+  @callback union(t, t) :: t
 
   defmacrop target(set) do
     quote do

lib/elixir/lib/stream.ex

@@ -85,7 +85,7 @@ defmodule Stream do
   Note the functions in this module are guaranteed to return enumerables.
   Since enumerables can have different shapes (structs, anonymous functions,
   and so on), the functions in this module may return any of those shapes
-  and this may change at any time. For example, a function that today
+  and that this may change at any time. For example, a function that today
   returns an anonymous function may return a struct in future releases.
   """
 
@@ -96,6 +96,7 @@ defmodule Stream do
   @type element :: any
   @type index   :: non_neg_integer
   @type default :: any
+  @opaque t     :: %__MODULE__{}
 
   # Require Stream.Reducers and its callbacks
   require Stream.Reducers, as: R
@@ -104,80 +105,83 @@ defmodule Stream do
     {:cont, acc}
   end
 
-  defmacrop next(fun, entry, acc) do
-    quote do: unquote(fun).(unquote(entry), unquote(acc))
+  defmacrop next(f, entry, acc) do
+    quote do: unquote(f).(unquote(entry), unquote(acc))
   end
 
-  defmacrop acc(head, state, tail) do
-    quote do: [unquote(head), unquote(state) | unquote(tail)]
+  defmacrop acc(h, n, t) do
+    quote do: [unquote(h), unquote(n)|unquote(t)]
   end
 
-  defmacrop next_with_acc(fun, entry, head, state, tail) do
+  defmacrop next_with_acc(f, entry, h, n, t) do
     quote do
-      {reason, [head | tail]} = unquote(fun).(unquote(entry), [unquote(head) | unquote(tail)])
-      {reason, [head, unquote(state) | tail]}
+      {reason, [h|t]} = unquote(f).(unquote(entry), [unquote(h)|unquote(t)])
+      {reason, [h, unquote(n)|t]}
     end
   end
 
   ## Transformers
 
-  # Deprecate on v1.7
-  @doc false
+  @doc """
+  Shortcut to `chunk(enum, n, n)`.
+  """
+  @spec chunk(Enumerable.t, non_neg_integer) :: Enumerable.t
   def chunk(enum, n), do: chunk(enum, n, n, nil)
 
-  # Deprecate on v1.7
-  @doc false
-  def chunk(enum, n, step, leftover \\ nil)
-      when is_integer(n) and n > 0 and is_integer(step) and step > 0 do
-    chunk_every(enum, n, step, leftover || :discard)
-  end
-
   @doc """
-  Shortcut to `chunk_every(enum, count, count)`.
-  """
-  @spec chunk_every(Enumerable.t, pos_integer) :: Enumerable.t
-  def chunk_every(enum, count), do: chunk_every(enum, count, count, [])
+  Streams the enumerable in chunks, containing `n` items each, where
+  each new chunk starts `step` elements into the enumerable.
 
-  @doc """
-  Streams the enumerable in chunks, containing `count` items each,
-  where each new chunk starts `step` elements into the enumerable.
-
-  `step` is optional and, if not passed, defaults to `count`, i.e.
-  chunks do not overlap.
-
-  If the last chunk does not have `count` elements to fill the chunk,
-  elements are taken from `leftover` to fill in the chunk. If `leftover`
-  does not have enough elements to fill the chunk, then a partial chunk
-  is returned with less than `count` elements.
-
-  If `:discard` is given in `leftover`, the last chunk is discarded
-  unless it has exactly `count` elements.
+  `step` is optional and, if not passed, defaults to `n`, i.e.
+  chunks do not overlap. If the final chunk does not have `n`
+  elements to fill the chunk, elements are taken as necessary
+  from `pad` if it was passed. If `pad` is passed and does not
+  have enough elements to fill the chunk, then the chunk is
+  returned anyway with less than `n` elements. If `pad` is not
+  passed at all or is `nil`, then the partial chunk is discarded
+  from the result.
 
   ## Examples
 
-      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 2) |> Enum.to_list
+      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 2) |> Enum.to_list
       [[1, 2], [3, 4], [5, 6]]
 
-      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, :discard) |> Enum.to_list
+      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2) |> Enum.to_list
       [[1, 2, 3], [3, 4, 5]]
 
-      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 2, [7]) |> Enum.to_list
+      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 2, [7]) |> Enum.to_list
       [[1, 2, 3], [3, 4, 5], [5, 6, 7]]
 
-      iex> Stream.chunk_every([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list
+      iex> Stream.chunk([1, 2, 3, 4, 5, 6], 3, 3, []) |> Enum.to_list
       [[1, 2, 3], [4, 5, 6]]
 
   """
-  @spec chunk_every(Enumerable.t, pos_integer, pos_integer, Enumerable.t | :discard) :: Enumerable.t
-  def chunk_every(enum, count, step, leftover \\ [])
-      when is_integer(count) and count > 0 and is_integer(step) and step > 0 do
-    R.chunk_every(&chunk_while/4, enum, count, step, leftover)
+  @spec chunk(Enumerable.t, pos_integer, pos_integer) :: Enumerable.t
+  @spec chunk(Enumerable.t, pos_integer, pos_integer, Enumerable.t | nil) :: Enumerable.t
+  def chunk(enum, n, step, pad \\ nil) when n > 0 and step > 0 do
+    limit = :erlang.max(n, step)
+    if is_nil(pad) do
+      lazy enum, {[], 0}, fn(f1) -> R.chunk(n, step, limit, f1) end
+    else
+      lazy enum, {[], 0},
+           fn(f1) -> R.chunk(n, step, limit, f1) end,
+           &do_chunk(&1, n, pad, &2)
+     end
+  end
+
+  defp do_chunk(acc(_, {_, 0}, _) = acc, _, _, _) do
+    {:cont, acc}
+  end
+
+  defp do_chunk(acc(h, {buffer, count} = old, t), n, pad, f1) do
+    buffer = :lists.reverse(buffer, Enum.take(pad, n - count))
+    next_with_acc(f1, buffer, h, old, t)
   end
 
   @doc """
-  Chunks the `enum` by buffering elements for which `fun` returns the same value.
-
-  Elements are only emitted when `fun` returns a new value or the `enum` finishes.
+  Chunks the `enum` by buffering elements for which `fun` returns
+  the same value and only emit them when `fun` returns a new value
+  or the `enum` finishes.
 
   ## Examples
 
@@ -188,54 +192,20 @@ defmodule Stream do
   """
   @spec chunk_by(Enumerable.t, (element -> any)) :: Enumerable.t
   def chunk_by(enum, fun) do
-    R.chunk_by(&chunk_while/4, enum, fun)
+    lazy enum, nil,
+         fn(f1) -> R.chunk_by(fun, f1) end,
+         &do_chunk_by(&1, &2)
   end
 
-  @doc """
-  Chunks the `enum` with fine grained control when every chunk is emitted.
-
-  `chunk_fun` receives the current element and the accumulator and
-  must return `{:cont, element, acc}` to emit the given chunk and
-  continue with accumulator or `{:cont, acc}` to not emit any chunk
-  and continue with the return accumulator.
-
-  `after_fun` is invoked when iteration is done and must also return
-  `{:cont, element, acc}` or `{:cont, acc}`.
-
-  ## Examples
-
-      iex> chunk_fun = fn i, acc ->
-      ...>   if rem(i, 2) == 0 do
-      ...>     {:cont, Enum.reverse([i | acc]), []}
-      ...>   else
-      ...>     {:cont, [i | acc]}
-      ...>   end
-      ...> end
-      iex> after_fun = fn
-      ...>   [] -> {:cont, []}
-      ...>   acc -> {:cont, Enum.reverse(acc), []}
-      ...> end
-      iex> stream = Stream.chunk_while(1..10, [], chunk_fun, after_fun)
-      iex> Enum.to_list(stream)
-      [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
-
-  """
-  @spec chunk_while(Enumerable.t, acc,
-                    (element, acc -> {:cont, chunk, acc} | {:cont, acc} | {:halt, acc}),
-                    (acc -> {:cont, chunk, acc} | {:cont, acc})) :: Enumerable.t when chunk: any
-  def chunk_while(enum, acc, chunk_fun, after_fun) do
-    lazy enum, acc,
-         fn(f1) -> R.chunk_while(chunk_fun, f1) end,
-         &after_chunk_while(&1, &2, after_fun)
+  defp do_chunk_by(acc(_, nil, _) = acc, _f1) do
+    {:cont, acc}
   end
 
-  defp after_chunk_while(acc(h, acc, t), f1, after_fun) do
-    case after_fun.(acc) do
-      {:cont, emit, acc} -> next_with_acc(f1, emit, h, acc, t)
-      {:cont, acc} -> {:cont, acc(h, acc, t)}
-    end
+  defp do_chunk_by(acc(h, {buffer, _}, t), f1) do
+    next_with_acc(f1, :lists.reverse(buffer), h, nil, t)
   end
 
+
   @doc """
   Creates a stream that only emits elements if they are different from the last emitted element.
 
@@ -265,7 +235,7 @@ defmodule Stream do
 
   """
   @spec dedup_by(Enumerable.t, (element -> term)) :: Enumerable.t
-  def dedup_by(enum, fun) do
+  def dedup_by(enum, fun) when is_function(fun, 1) do
     lazy enum, nil, fn f1 -> R.dedup(fun, f1) end
   end
 
@@ -300,54 +270,23 @@ defmodule Stream do
       fn
         entry, [h, {count, buf1, []} | t] ->
           do_drop(:cont, n, entry, h, count, buf1, [], t)
-        entry, [h, {count, buf1, [next | buf2]} | t] ->
-          {reason, [h | t]} = f1.(next, [h | t])
+        entry, [h, {count, buf1, [next|buf2]} | t] ->
+          {reason, [h|t]} = f1.(next, [h|t])
           do_drop(reason, n, entry, h, count, buf1, buf2, t)
       end
     end
   end
 
   defp do_drop(reason, n, entry, h, count, buf1, buf2, t) do
-    buf1  = [entry | buf1]
+    buf1  = [entry|buf1]
     count = count + 1
     if count == n do
-      {reason, [h, {0, [], :lists.reverse(buf1)} | t]}
+      {reason, [h, {0, [], :lists.reverse(buf1)}|t]}
     else
-      {reason, [h, {count, buf1, buf2} | t]}
+      {reason, [h, {count, buf1, buf2}|t]}
     end
   end
 
-  @doc """
-  Creates a stream that drops every `nth` item from the enumerable.
-
-  The first item is always dropped, unless `nth` is 0.
-
-  `nth` must be a non-negative integer.
-
-  ## Examples
-
-      iex> stream = Stream.drop_every(1..10, 2)
-      iex> Enum.to_list(stream)
-      [2, 4, 6, 8, 10]
-
-      iex> stream = Stream.drop_every(1..1000, 1)
-      iex> Enum.to_list(stream)
-      []
-
-      iex> stream = Stream.drop_every([1, 2, 3, 4, 5], 0)
-      iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
-
-  """
-  @spec drop_every(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def drop_every(enum, nth)
-  def drop_every(enum, 0), do: %Stream{enum: enum}
-  def drop_every([], _nth), do: %Stream{enum: []}
-
-  def drop_every(enum, nth) when is_integer(nth) and nth > 0 do
-    lazy enum, nth, fn(f1) -> R.drop_every(nth, f1) end
-  end
-
   @doc """
   Lazily drops elements of the enumerable while the given
   function returns `true`.
@@ -371,7 +310,7 @@ defmodule Stream do
 
   ## Examples
 
-      iex> stream = Stream.each([1, 2, 3], fn(x) -> send self(), x end)
+      iex> stream = Stream.each([1, 2, 3], fn(x) -> send self, x end)
       iex> Enum.to_list(stream)
       iex> receive do: (x when is_integer(x) -> x)
       1
@@ -392,10 +331,8 @@ defmodule Stream do
   end
 
   @doc """
-  Maps the given `fun` over `enumerable` and flattens the result.
-
-  This function returns a new stream built by appending the result of invoking `fun`
-  on each element of `enumerable` together.
+  Creates a stream that will apply the given function on enumeration and
+  flatten the result.
 
   ## Examples
 
@@ -403,10 +340,6 @@ defmodule Stream do
       iex> Enum.to_list(stream)
       [1, 2, 2, 4, 3, 6]
 
-      iex> stream = Stream.flat_map([1, 2, 3], fn(x) -> [[x]] end)
-      iex> Enum.to_list(stream)
-      [[1], [2], [3]]
-
   """
   @spec flat_map(Enumerable.t, (element -> Enumerable.t)) :: Enumerable.t
   def flat_map(enum, mapper) do
@@ -429,24 +362,28 @@ defmodule Stream do
     lazy enum, fn(f1) -> R.filter(fun, f1) end
   end
 
-  @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
+  @doc """
+  Creates a stream that filters and then maps elements according
+  to given functions.
+
+  Exists for symmetry with `Enum.filter_map/3`.
+
+  ## Examples
+
+      iex> stream = Stream.filter_map(1..6, fn(x) -> rem(x, 2) == 0 end, &(&1 * 2))
+      iex> Enum.to_list(stream)
+      [4, 8, 12]
+
+  """
+  @spec filter_map(Enumerable.t, (element -> as_boolean(term)), (element -> any)) :: Enumerable.t
   def filter_map(enum, filter, mapper) do
     lazy enum, fn(f1) -> R.filter_map(filter, mapper, f1) end
   end
 
   @doc """
-  Creates a stream that emits a value after the given period `n`
-  in milliseconds.
+  Creates a stream that emits a value after the given period `n` in milliseconds.
 
   The values emitted are an increasing counter starting at `0`.
-  This operation will block the caller by the given interval
-  every time a new item is streamed.
-
-  Do not use this function to generate a sequence of numbers.
-  If blocking the caller process is not necessary, use
-  `Stream.iterate(0, & &1 + 1)` instead.
 
   ## Examples
 
@@ -454,10 +391,11 @@ defmodule Stream do
       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 
   """
+  # TODO: Allow it to handle system messages.
   @spec interval(non_neg_integer) :: Enumerable.t
   def interval(n) do
-    unfold 0, fn(count) ->
-      Process.sleep(n)
+    unfold 0, fn (count) ->
+      :timer.sleep(n)
       {count, count + 1}
     end
   end
@@ -468,33 +406,33 @@ defmodule Stream do
   This function is often used with `run/1` since any evaluation
   is delayed until the stream is executed. See `run/1` for an example.
   """
-  @spec into(Enumerable.t, Collectable.t, (term -> term)) :: Enumerable.t
+  @spec into(Enumerable.t, Collectable.t) :: Enumerable.t
   def into(enum, collectable, transform \\ fn x -> x end) do
     &do_into(enum, collectable, transform, &1, &2)
   end
 
   defp do_into(enum, collectable, transform, acc, fun) do
     {initial, into} = Collectable.into(collectable)
-    composed = fn x, [acc | collectable] ->
+    composed = fn x, [acc|collectable] ->
       collectable = into.(collectable, {:cont, transform.(x)})
       {reason, acc} = fun.(x, acc)
-      {reason, [acc | collectable]}
+      {reason, [acc|collectable]}
     end
     do_into(&Enumerable.reduce(enum, &1, composed), initial, into, acc)
   end
 
   defp do_into(reduce, collectable, into, {command, acc}) do
     try do
-      reduce.({command, [acc | collectable]})
+      reduce.({command, [acc|collectable]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         into.(collectable, :halt)
         :erlang.raise(kind, reason, stacktrace)
     else
-      {:suspended, [acc | collectable], continuation} ->
+      {:suspended, [acc|collectable], continuation} ->
         {:suspended, acc, &do_into(continuation, collectable, into, &1)}
-      {reason, [acc | collectable]} ->
+      {reason, [acc|collectable]} ->
         into.(collectable, :done)
         {reason, acc}
     end
@@ -516,41 +454,6 @@ defmodule Stream do
     lazy enum, fn(f1) -> R.map(fun, f1) end
   end
 
-  @doc """
-  Creates a stream that will apply the given function on
-  every `nth` item from the enumerable.
-
-  The first item is always passed to the given function.
-
-  `nth` must be a non-negative integer.
-
-  ## Examples
-
-      iex> stream = Stream.map_every(1..10, 2, fn(x) -> x * 2 end)
-      iex> Enum.to_list(stream)
-      [2, 2, 6, 4, 10, 6, 14, 8, 18, 10]
-
-      iex> stream = Stream.map_every([1, 2, 3, 4, 5], 1, fn(x) -> x * 2 end)
-      iex> Enum.to_list(stream)
-      [2, 4, 6, 8, 10]
-
-      iex> stream = Stream.map_every(1..5, 0, fn(x) -> x * 2 end)
-      iex> Enum.to_list(stream)
-      [1, 2, 3, 4, 5]
-
-  """
-  @spec map_every(Enumerable.t, non_neg_integer, (element -> any)) :: Enumerable.t
-  def map_every(enum, nth, fun)
-
-  def map_every(enum, 1, fun), do: map(enum, fun)
-  def map_every(enum, 0, _fun), do: %Stream{enum: enum}
-  def map_every([], _nth, _fun), do: %Stream{enum: []}
-
-  def map_every(enum, nth, fun) when is_integer(nth) and nth > 0 do
-    lazy enum, nth, fn(f1) -> R.map_every(nth, fun, f1) end
-  end
-
-
   @doc """
   Creates a stream that will reject elements according to
   the given function on enumeration.
@@ -595,8 +498,7 @@ defmodule Stream do
   @doc """
   Creates a stream that applies the given function to each
   element, emits the result and uses the same result as the accumulator
-  for the next computation. Uses the first element in the enumerable
-  as the starting value.
+  for the next computation.
 
   ## Examples
 
@@ -607,7 +509,7 @@ defmodule Stream do
   """
   @spec scan(Enumerable.t, (element, acc -> any)) :: Enumerable.t
   def scan(enum, fun) do
-    lazy enum, :first, fn(f1) -> R.scan2(fun, f1) end
+    lazy enum, :first, fn(f1) -> R.scan_2(fun, f1) end
   end
 
   @doc """
@@ -624,7 +526,7 @@ defmodule Stream do
   """
   @spec scan(Enumerable.t, acc, (element, acc -> any)) :: Enumerable.t
   def scan(enum, acc, fun) do
-    lazy enum, acc, fn(f1) -> R.scan3(fun, f1) end
+    lazy enum, acc, fn(f1) -> R.scan_3(fun, f1) end
   end
 
   @doc """
@@ -669,7 +571,7 @@ defmodule Stream do
 
   The first item is always included, unless `nth` is 0.
 
-  `nth` must be a non-negative integer.
+  `nth` must be a non-negative integer, or `FunctionClauseError` will be thrown.
 
   ## Examples
 
@@ -687,7 +589,6 @@ defmodule Stream do
 
   """
   @spec take_every(Enumerable.t, non_neg_integer) :: Enumerable.t
-  def take_every(enum, nth)
   def take_every(_enum, 0), do: %Stream{enum: []}
   def take_every([], _nth), do: %Stream{enum: []}
 
@@ -714,8 +615,7 @@ defmodule Stream do
   @doc """
   Creates a stream that emits a single value after `n` milliseconds.
 
-  The value emitted is `0`. This operation will block the caller by
-  the given time until the item is streamed.
+  The value emitted is `0`.
 
   ## Examples
 
@@ -755,10 +655,10 @@ defmodule Stream do
       [1, 2, 3]
 
   """
-  @spec transform(Enumerable.t, acc, fun) :: Enumerable.t
-        when fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
-             acc: any
-  def transform(enum, acc, reducer) do
+  @spec transform(Enumerable.t, acc, fun) :: Enumerable.t when
+        fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
+        acc: any
+  def transform(enum, acc, reducer) when is_function(reducer, 2) do
     &do_transform(enum, fn -> acc end, reducer, &1, &2, nil)
   end
 
@@ -772,10 +672,11 @@ defmodule Stream do
   This function can be seen as a combination of `Stream.resource/3` with
   `Stream.transform/3`.
   """
-  @spec transform(Enumerable.t, (() -> acc), fun, (acc -> term)) :: Enumerable.t
-        when fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
-             acc: any
-  def transform(enum, start_fun, reducer, after_fun) do
+  @spec transform(Enumerable.t, (() -> acc), fun, (acc -> term)) :: Enumerable.t when
+        fun: (element, acc -> {Enumerable.t, acc} | {:halt, acc}),
+        acc: any
+  def transform(enum, start_fun, reducer, after_fun)
+      when is_function(start_fun, 0) and is_function(reducer, 2) and is_function(after_fun, 1) do
     &do_transform(enum, start_fun, reducer, &1, &2, after_fun)
   end
 
@@ -783,125 +684,107 @@ defmodule Stream do
     inner = &do_transform_each(&1, &2, fun)
     step  = &do_transform_step(&1, &2)
     next  = &Enumerable.reduce(enumerables, &1, step)
-    do_transform(user_acc.(), user, fun, :cont, next, inner_acc, inner, after_fun)
+    do_transform(user_acc.(), user, fun, [], next, inner_acc, inner, after_fun)
   end
 
-  defp do_transform(user_acc, _user, _fun, _next_op, next, {:halt, inner_acc}, _inner, after_fun) do
-    next.({:halt, []})
+  defp do_transform(user_acc, _user, _fun, _next_acc, _next, {:halt, inner_acc}, _inner, after_fun) do
     do_after(after_fun, user_acc)
     {:halted, inner_acc}
   end
 
-  defp do_transform(user_acc, user, fun, next_op, next, {:suspend, inner_acc}, inner, after_fun) do
-    {:suspended, inner_acc, &do_transform(user_acc, user, fun, next_op, next, &1, inner, after_fun)}
+  defp do_transform(user_acc, user, fun, next_acc, next, {:suspend, inner_acc}, inner, after_fun) do
+    {:suspended, inner_acc, &do_transform(user_acc, user, fun, next_acc, next, &1, inner, after_fun)}
   end
 
-  defp do_transform(user_acc, _user, _fun, :halt, _next, {_, inner_acc}, _inner, after_fun) do
-    do_after(after_fun, user_acc)
-    {:halted, inner_acc}
-  end
-
-  defp do_transform(user_acc, user, fun, :cont, next, inner_acc, inner, after_fun) do
-    try do
-      next.({:cont, []})
-    catch
-      kind, reason ->
-        stacktrace = System.stacktrace
+  defp do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, after_fun) do
+    case next.({:cont, next_acc}) do
+      {:suspended, [val|next_acc], next} ->
+        try do
+          user.(val, user_acc)
+        catch
+          kind, reason ->
+            stacktrace = System.stacktrace
+            next.({:halt, next_acc})
+            do_after(after_fun, user_acc)
+            :erlang.raise(kind, reason, stacktrace)
+        else
+          {[], user_acc} ->
+            do_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, after_fun)
+          {list, user_acc} when is_list(list) ->
+            do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner,
+                              &Enumerable.List.reduce(list, &1, fun), after_fun)
+          {:halt, user_acc} ->
+            next.({:halt, next_acc})
+            do_after(after_fun, user_acc)
+            {:halted, elem(inner_acc, 1)}
+          {other, user_acc} ->
+            do_enum_transform(user_acc, user, fun, next_acc, next, inner_acc, inner,
+                              &Enumerable.reduce(other, &1, inner), after_fun)
+        end
+      {reason, _} ->
         do_after(after_fun, user_acc)
-        :erlang.raise(kind, reason, stacktrace)
-    else
-      {:suspended, vals, next} ->
-        do_transform_user(:lists.reverse(vals), user_acc, user, fun, :cont, next, inner_acc, inner, after_fun)
-      {_, vals} ->
-        do_transform_user(:lists.reverse(vals), user_acc, user, fun, :halt, next, inner_acc, inner, after_fun)
+        {reason, elem(inner_acc, 1)}
     end
   end
 
-  defp do_transform_user([], user_acc, user, fun, next_op, next, inner_acc, inner, after_fun) do
-    do_transform(user_acc, user, fun, next_op, next, inner_acc, inner, after_fun)
-  end
-
-  defp do_transform_user([val | vals], user_acc, user, fun, next_op, next, inner_acc, inner, after_fun) do
-    user.(val, user_acc)
-  catch
-    kind, reason ->
-      stacktrace = System.stacktrace
-      next.({:halt, []})
-      do_after(after_fun, user_acc)
-      :erlang.raise(kind, reason, stacktrace)
-  else
-    {[], user_acc} ->
-      do_transform_user(vals, user_acc, user, fun, next_op, next, inner_acc, inner, after_fun)
-    {list, user_acc} when is_list(list) ->
-      do_list_transform(vals, user_acc, user, fun, next_op, next, inner_acc, inner,
-                        &Enumerable.List.reduce(list, &1, fun), after_fun)
-    {:halt, user_acc} ->
-      next.({:halt, []})
-      do_after(after_fun, user_acc)
-      {:halted, elem(inner_acc, 1)}
-    {other, user_acc} ->
-      do_enum_transform(vals, user_acc, user, fun, next_op, next, inner_acc, inner,
-                        &Enumerable.reduce(other, &1, inner), after_fun)
-  end
-
-  defp do_list_transform(vals, user_acc, user, fun, next_op, next, inner_acc, inner, reduce, after_fun) do
+  defp do_list_transform(user_acc, user, fun, next_acc, next, inner_acc, inner, reduce, after_fun) do
     try do
       reduce.(inner_acc)
     catch
       kind, reason ->
         stacktrace = System.stacktrace
-        next.({:halt, []})
+        next.({:halt, next_acc})
         do_after(after_fun, user_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
       {:done, acc} ->
-        do_transform_user(vals, user_acc, user, fun, next_op, next, {:cont, acc}, inner, after_fun)
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
       {:halted, acc} ->
-        next.({:halt, []})
+        next.({:halt, next_acc})
         do_after(after_fun, user_acc)
         {:halted, acc}
       {:suspended, acc, c} ->
-        {:suspended, acc, &do_list_transform(vals, user_acc, user, fun, next_op, next, &1, inner, c, after_fun)}
+        {:suspended, acc, &do_list_transform(user_acc, user, fun, next_acc, next, &1, inner, c, after_fun)}
     end
   end
 
-  defp do_enum_transform(vals, user_acc, user, fun, next_op, next, {op, inner_acc}, inner, reduce, after_fun) do
+  defp do_enum_transform(user_acc, user, fun, next_acc, next, {op, inner_acc}, inner, reduce, after_fun) do
     try do
-      reduce.({op, [:outer | inner_acc]})
+      reduce.({op, [:outer|inner_acc]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
-        next.({:halt, []})
+        next.({:halt, next_acc})
         do_after(after_fun, user_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
       # Only take into account outer halts when the op is not halt itself.
       # Otherwise, we were the ones wishing to halt, so we should just stop.
-      {:halted, [:outer | acc]} when op != :halt ->
-        do_transform_user(vals, user_acc, user, fun, next_op, next, {:cont, acc}, inner, after_fun)
-      {:halted, [_ | acc]} ->
-        next.({:halt, []})
+      {:halted, [:outer|acc]} when op != :halt ->
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
+      {:halted, [_|acc]} ->
+        next.({:halt, next_acc})
         do_after(after_fun, user_acc)
         {:halted, acc}
-      {:done, [_ | acc]} ->
-        do_transform_user(vals, user_acc, user, fun, next_op, next, {:cont, acc}, inner, after_fun)
-      {:suspended, [_ | acc], c} ->
-        {:suspended, acc, &do_enum_transform(vals, user_acc, user, fun, next_op, next, &1, inner, c, after_fun)}
+      {:done, [_|acc]} ->
+        do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
+      {:suspended, [_|acc], c} ->
+        {:suspended, acc, &do_enum_transform(user_acc, user, fun, next_acc, next, &1, inner, c, after_fun)}
     end
   end
 
   defp do_after(nil, _user_acc), do: :ok
   defp do_after(fun, user_acc),  do: fun.(user_acc)
 
-  defp do_transform_each(x, [:outer | acc], f) do
+  defp do_transform_each(x, [:outer|acc], f) do
     case f.(x, acc) do
-      {:halt, res} -> {:halt, [:inner | res]}
-      {op, res}    -> {op, [:outer | res]}
+      {:halt, res} -> {:halt, [:inner|res]}
+      {op, res}    -> {op, [:outer|res]}
     end
   end
 
   defp do_transform_step(x, acc) do
-    {:suspend, [x | acc]}
+    {:suspend, [x|acc]}
   end
 
   @doc """
@@ -917,51 +800,20 @@ defmodule Stream do
       iex> Stream.uniq([1, 2, 3, 3, 2, 1]) |> Enum.to_list
       [1, 2, 3]
 
-  """
-  @spec uniq(Enumerable.t) :: Enumerable.t
-  def uniq(enum) do
-    uniq_by(enum, fn x -> x end)
-  end
-
-  @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def uniq(enum, fun) do
-    uniq_by(enum, fun)
-  end
-
-  @doc """
-  Creates a stream that only emits elements if they are unique, by removing the
-  elements for which function `fun` returned duplicate items.
-
-  The function `fun` maps every element to a term which is used to
-  determine if two elements are duplicates.
-
-  Keep in mind that, in order to know if an element is unique
-  or not, this function needs to store all unique values emitted
-  by the stream. Therefore, if the stream is infinite, the number
-  of items stored will grow infinitely, never being garbage collected.
-
-  ## Example
-
-      iex> Stream.uniq_by([{1, :x}, {2, :y}, {1, :z}], fn {x, _} -> x end) |> Enum.to_list
+      iex> Stream.uniq([{1, :x}, {2, :y}, {2, :z}, {1, :x}], fn {x, _} -> x end) |> Enum.to_list
       [{1, :x}, {2, :y}]
 
-      iex> Stream.uniq_by([a: {:tea, 2}, b: {:tea, 2}, c: {:coffee, 1}], fn {_, y} -> y end) |> Enum.to_list
-      [a: {:tea, 2}, c: {:coffee, 1}]
-
   """
-  @spec uniq_by(Enumerable.t, (element -> term)) :: Enumerable.t
-  def uniq_by(enum, fun) do
-    lazy enum, %{}, fn f1 -> R.uniq_by(fun, f1) end
+  @spec uniq(Enumerable.t) :: Enumerable.t
+  @spec uniq(Enumerable.t, (element -> term)) :: Enumerable.t
+  def uniq(enum, fun \\ fn x -> x end) do
+    lazy enum, %{}, fn f1 -> R.uniq(fun, f1) end
   end
 
   @doc """
   Creates a stream where each item in the enumerable will
   be wrapped in a tuple alongside its index.
 
-  If an `offset` is given, we will index from the given offset instead of from zero.
-
   ## Examples
 
       iex> stream = Stream.with_index([1, 2, 3])
@@ -973,6 +825,7 @@ defmodule Stream do
       [{1, 3}, {2, 4}, {3, 5}]
 
   """
+  @spec with_index(Enumerable.t) :: Enumerable.t
   @spec with_index(Enumerable.t, integer) :: Enumerable.t
   def with_index(enum, offset \\ 0) do
     lazy enum, offset, fn(f1) -> R.with_index(f1) end
@@ -1030,35 +883,15 @@ defmodule Stream do
 
   """
   @spec zip(Enumerable.t, Enumerable.t) :: Enumerable.t
-  def zip(left, right), do: zip([left, right])
-
-  @doc """
-  Zips corresponding elements from a collection of enumerables
-  into one stream of tuples.
-
-  The zipping finishes as soon as any enumerable completes.
-
-  ## Examples
-
-      iex> concat = Stream.concat(1..3, 4..6)
-      iex> cycle = Stream.cycle(["foo", "bar", "baz"])
-      iex> Stream.zip([concat, [:a, :b, :c], cycle]) |> Enum.to_list
-      [{1, :a, "foo"}, {2, :b, "bar"}, {3, :c, "baz"}]
-
-  """
-  @spec zip([Enumerable.t]) :: Enumerable.t
-  def zip(enumerables) do
+  def zip(left, right) do
     step      = &do_zip_step(&1, &2)
-    enum_funs = Enum.map(enumerables, fn enum ->
-      {&Enumerable.reduce(enum, &1, step), :cont}
-    end)
+    left_fun  = &Enumerable.reduce(left, &1, step)
+    right_fun = &Enumerable.reduce(right, &1, step)
 
-    &do_zip(enum_funs, &1, &2)
+    # Return a function as a lazy enumerator.
+    &do_zip([{left_fun, []}, {right_fun, []}], &1, &2)
   end
 
-  # This implementation of do_zip/3 works for any number of
-  # streams to zip, even if right now zip/2 only zips two streams.
-
   defp do_zip(zips, {:halt, acc}, _fun) do
     do_zip_close(zips)
     {:halted, acc}
@@ -1070,7 +903,7 @@ defmodule Stream do
 
   defp do_zip(zips, {:cont, acc}, callback) do
     try do
-      do_zip_next_tuple(zips, acc, callback, [], [])
+      do_zip(zips, acc, callback, [], [])
     catch
       kind, reason ->
         stacktrace = System.stacktrace
@@ -1079,47 +912,34 @@ defmodule Stream do
     else
       {:next, buffer, acc} ->
         do_zip(buffer, acc, callback)
-      {:done, _acc} = other ->
-        other
+      {:done, _} = o ->
+        o
     end
   end
 
-  # do_zip_next_tuple/5 computes the next tuple formed by
-  # the next element of each zipped stream.
-
-  defp do_zip_next_tuple([{_, :halt} | zips], acc, _callback, _yielded_elems, buffer) do
-    do_zip_close(:lists.reverse(buffer, zips))
-    {:done, acc}
-  end
-
-  defp do_zip_next_tuple([{fun, :cont} | zips], acc, callback, yielded_elems, buffer) do
-    case fun.({:cont, []}) do
-      {:suspended, [elem], fun} ->
-        do_zip_next_tuple(zips, acc, callback, [elem | yielded_elems], [{fun, :cont} | buffer])
-      {_, [elem]} ->
-        do_zip_next_tuple(zips, acc, callback, [elem | yielded_elems], [{fun, :halt} | buffer])
-      {_, []} ->
-        # The current zipped stream terminated, so we close all the streams
-        # and return {:halted, acc} (which is returned as is by do_zip/3).
-        do_zip_close(:lists.reverse(buffer, zips))
+  defp do_zip([{fun, fun_acc}|t], acc, callback, list, buffer) do
+    case fun.({:cont, fun_acc}) do
+      {:suspended, [i|fun_acc], fun} ->
+        do_zip(t, acc, callback, [i|list], [{fun, fun_acc}|buffer])
+      {_, _} ->
+        do_zip_close(:lists.reverse(buffer, t))
         {:done, acc}
     end
   end
 
-  defp do_zip_next_tuple([] = _zips, acc, callback, yielded_elems, buffer) do
-    # "yielded_elems" is a reversed list of results for the current iteration of
-    # zipping: it needs to be reversed and converted to a tuple to have the next
-    # tuple in the list resulting from zipping.
-    zipped = List.to_tuple(:lists.reverse(yielded_elems))
+  defp do_zip([], acc, callback, list, buffer) do
+    zipped = List.to_tuple(:lists.reverse(list))
     {:next, :lists.reverse(buffer), callback.(zipped, acc)}
   end
 
-  defp do_zip_close(zips) do
-    :lists.foreach(fn {fun, _} -> fun.({:halt, []}) end, zips)
+  defp do_zip_close([]), do: :ok
+  defp do_zip_close([{fun, acc}|t]) do
+    fun.({:halt, acc})
+    do_zip_close(t)
   end
 
-  defp do_zip_step(x, []) do
-    {:suspend, [x]}
+  defp do_zip_step(x, acc) do
+    {:suspend, [x|acc]}
   end
 
   ## Sources
@@ -1138,10 +958,6 @@ defmodule Stream do
   @spec cycle(Enumerable.t) :: Enumerable.t
   def cycle(enumerable)
 
-  def cycle([]) do
-    raise ArgumentError, "cannot cycle over empty enumerable"
-  end
-
   def cycle(enumerable) when is_list(enumerable) do
     unfold {enumerable, enumerable}, fn
       {source, [h | t]}      -> {h, {source, t}}
@@ -1172,8 +988,6 @@ defmodule Stream do
       {:stream_cycle, acc} ->
         {:halted, acc}
     else
-      {state, []} when state in [:done, :halted] ->
-        raise ArgumentError, "cannot cycle over empty enumerable"
       {state, acc} when state in [:done, :halted] ->
         do_cycle(cycle, cycle, {:cont, acc})
       {:suspended, acc, continuation} ->
@@ -1221,7 +1035,7 @@ defmodule Stream do
 
   """
   @spec repeatedly((() -> element)) :: Enumerable.t
-  def repeatedly(generator_fun) do
+  def repeatedly(generator_fun) when is_function(generator_fun, 0) do
     &do_repeatedly(generator_fun, &1, &2)
   end
 
@@ -1240,7 +1054,7 @@ defmodule Stream do
   @doc """
   Emits a sequence of values for the given resource.
 
-  Similar to `transform/3` but the initial accumulated value is
+  Similar to `transform/2` but the initial accumulated value is
   computed lazily via `start_fun` and executes an `after_fun` at
   the end of enumeration (both in cases of success and failure).
 
@@ -1265,7 +1079,7 @@ defmodule Stream do
                       fn file -> File.close(file) end)
 
   """
-  @spec resource((() -> acc), (acc -> {[element], acc} | {:halt, acc}), (acc -> term)) :: Enumerable.t
+  @spec resource((() -> acc), (acc -> {element, acc} | nil), (acc -> term)) :: Enumerable.t
   def resource(start_fun, next_fun, after_fun) do
     &do_resource(start_fun.(), next_fun, &1, &2, after_fun)
   end
@@ -1327,28 +1141,28 @@ defmodule Stream do
 
   defp do_enum_resource(next_acc, next_fun, {op, acc}, fun, after_fun, reduce) do
     try do
-      reduce.({op, [:outer | acc]})
+      reduce.({op, [:outer|acc]})
     catch
       kind, reason ->
         stacktrace = System.stacktrace
         after_fun.(next_acc)
         :erlang.raise(kind, reason, stacktrace)
     else
-      {:halted, [:outer | acc]} ->
+      {:halted, [:outer|acc]} ->
         do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
-      {:halted, [:inner | acc]} ->
+      {:halted, [:inner|acc]} ->
         do_resource(next_acc, next_fun, {:halt, acc}, fun, after_fun)
-      {:done, [_ | acc]} ->
+      {:done, [_|acc]} ->
         do_resource(next_acc, next_fun, {:cont, acc}, fun, after_fun)
-      {:suspended, [_ | acc], c} ->
+      {:suspended, [_|acc], c} ->
         {:suspended, acc, &do_enum_resource(next_acc, next_fun, &1, fun, after_fun, c)}
     end
   end
 
-  defp do_resource_each(x, [:outer | acc], f) do
+  defp do_resource_each(x, [:outer|acc], f) do
     case f.(x, acc) do
-      {:halt, res} -> {:halt, [:inner | res]}
-      {op, res}    -> {op, [:outer | res]}
+      {:halt, res} -> {:halt, [:inner|res]}
+      {op, res}    -> {op, [:outer|res]}
     end
   end
 
@@ -1390,17 +1204,17 @@ defmodule Stream do
   @compile {:inline, lazy: 2, lazy: 3, lazy: 4}
 
   defp lazy(%Stream{done: nil, funs: funs} = lazy, fun),
-    do: %{lazy | funs: [fun | funs]}
+    do: %{lazy | funs: [fun|funs] }
   defp lazy(enum, fun),
     do: %Stream{enum: enum, funs: [fun]}
 
   defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun),
-    do: %{lazy | funs: [fun | funs], accs: [acc | accs]}
+    do: %{lazy | funs: [fun|funs], accs: [acc|accs] }
   defp lazy(enum, acc, fun),
     do: %Stream{enum: enum, funs: [fun], accs: [acc]}
 
   defp lazy(%Stream{done: nil, funs: funs, accs: accs} = lazy, acc, fun, done),
-    do: %{lazy | funs: [fun | funs], accs: [acc | accs], done: done}
+    do: %{lazy | funs: [fun|funs], accs: [acc|accs], done: done}
   defp lazy(enum, acc, fun, done),
     do: %Stream{enum: enum, funs: [fun], accs: [acc], done: done}
 end
@@ -1430,8 +1244,8 @@ defimpl Enumerable, for: Stream do
   end
 
   defp do_each(reduce, done, accs, {command, acc}) do
-    case reduce.({command, [acc | accs]}) do
-      {:suspended, [acc | accs], continuation} ->
+    case reduce.({command, [acc|accs]}) do
+      {:suspended, [acc|accs], continuation} ->
         {:suspended, acc, &do_each(continuation, done, accs, &1)}
       {:halted, accs} ->
         do_done {:halted, accs}, done
@@ -1440,13 +1254,13 @@ defimpl Enumerable, for: Stream do
     end
   end
 
-  defp do_done({reason, [acc | _]}, nil), do: {reason, acc}
-  defp do_done({reason, [acc | t]}, {done, fun}) do
-    [h | _] = Enum.reverse(t)
+  defp do_done({reason, [acc|_]}, nil), do: {reason, acc}
+  defp do_done({reason, [acc|t]}, {done, fun}) do
+    [h|_] = Enum.reverse(t)
     case done.([acc, h], fun) do
-      {:cont, [acc | _]}    -> {reason, acc}
-      {:halt, [acc | _]}    -> {:halted, acc}
-      {:suspend, [acc | _]} -> {:suspended, acc, &({:done, elem(&1, 1)})}
+      {:cont, [acc|_]}    -> {reason, acc}
+      {:halt, [acc|_]}    -> {:halted, acc}
+      {:suspend, [acc|_]} -> {:suspended, acc, &({:done, elem(&1, 1)})}
     end
   end
 end

lib/elixir/lib/stream/reducers.ex

@@ -1,113 +1,86 @@
 defmodule Stream.Reducers do
-  # Collection of reducers and utilities shared by Enum and Stream.
+  # Collection of reducers shared by Enum and Stream.
   @moduledoc false
 
-  def chunk_every(chunk_by, enumerable, count, step, leftover) do
-    limit = :erlang.max(count, step)
-    chunk_by.(enumerable, {[], 0}, fn entry, {acc_buffer, acc_count} ->
-      acc_buffer = [entry | acc_buffer]
-      acc_count = acc_count + 1
-
-      new_state =
-        if acc_count >= limit do
-          remaining = acc_count - step
-          {Enum.take(acc_buffer, remaining), remaining}
-        else
-          {acc_buffer, acc_count}
-        end
-
-      if acc_count == count do
-        {:cont, :lists.reverse(acc_buffer), new_state}
-      else
-        {:cont, new_state}
-      end
-    end, fn {acc_buffer, acc_count} ->
-      if leftover == :discard or acc_count == 0 or (step > count and acc_count >= count) do
-        {:cont, []}
-      else
-        {:cont, :lists.reverse(acc_buffer, Enum.take(leftover, count - acc_count)), []}
-      end
-    end)
-  end
-
-  def chunk_by(chunk_by, enumerable, fun) do
-    chunk_by.(enumerable, nil, fn
-      entry, nil ->
-        {:cont, {[entry], fun.(entry)}}
-      entry, {acc, value} ->
-        case fun.(entry) do
-          ^value -> {:cont, {[entry | acc], value}}
-          new_value -> {:cont, :lists.reverse(acc), {[entry], new_value}}
-        end
-    end, fn
-      nil -> {:cont, :done}
-      {acc, _value} -> {:cont, :lists.reverse(acc), :done}
-    end)
-  end
-
-  defmacro chunk_while(callback, fun \\ nil) do
+  defmacro chunk(n, step, limit, f \\ nil) do
     quote do
-      fn entry, acc(head, acc, tail) ->
-        case unquote(callback).(entry, acc) do
-          {:cont, emit, acc} -> next_with_acc(unquote(fun), emit, head, acc, tail)
-          {:cont, acc} -> skip(acc(head, acc, tail))
-          {:halt, acc} -> {:halt, acc(head, acc, tail)}
+      fn entry, acc(h, {buffer, count}, t) ->
+        buffer = [entry|buffer]
+        count  = count + 1
+
+        new =
+          if count >= unquote(limit) do
+            left = count - unquote(step)
+            {Enum.take(buffer, left), left}
+          else
+            {buffer, count}
+          end
+
+        if count == unquote(n) do
+          next_with_acc(unquote(f), :lists.reverse(buffer), h, new, t)
+        else
+          skip(acc(h, new, t))
         end
       end
     end
   end
 
-  defmacro dedup(callback, fun \\ nil) do
+  defmacro chunk_by(callback, f \\ nil) do
     quote do
-      fn entry, acc(head, prev, tail) = acc ->
+      fn
+        entry, acc(h, {buffer, value}, t) ->
+          new_value = unquote(callback).(entry)
+          if new_value == value do
+            skip(acc(h, {[entry|buffer], value}, t))
+          else
+            next_with_acc(unquote(f), :lists.reverse(buffer), h, {[entry], new_value}, t)
+          end
+        entry, acc(h, nil, t) ->
+          skip(acc(h, {[entry], unquote(callback).(entry)}, t))
+      end
+    end
+  end
+
+  defmacro dedup(callback, f \\ nil) do
+    quote do
+      fn(entry, acc(h, prev, t) = acc) ->
         value = unquote(callback).(entry)
         case prev do
-          {:value, ^value} -> skip(acc)
-          _ -> next_with_acc(unquote(fun), entry, head, {:value, value}, tail)
+          {:value, ^value}  -> skip(acc)
+          _ -> next_with_acc(unquote(f), entry, h, {:value, value}, t)
         end
       end
     end
   end
 
-  defmacro drop(fun \\ nil) do
+  defmacro drop(f \\ nil) do
     quote do
       fn
-        _entry, acc(head, amount, tail) when amount > 0 ->
-          skip(acc(head, amount - 1, tail))
-        entry, acc(head, amount, tail) ->
-          next_with_acc(unquote(fun), entry, head, amount, tail)
+        _entry, acc(h, n, t) when n > 0 ->
+          skip(acc(h, n-1, t))
+        entry, acc(h, n, t) ->
+          next_with_acc(unquote(f), entry, h, n, t)
       end
     end
   end
 
-  defmacro drop_every(nth, fun \\ nil) do
+  defmacro drop_while(callback, f \\ nil) do
     quote do
-      fn
-        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
-          skip(acc(head, 1, tail))
-        entry, acc(head, curr, tail) ->
-          next_with_acc(unquote(fun), entry, head, curr + 1, tail)
-      end
-    end
-  end
-
-  defmacro drop_while(callback, fun \\ nil) do
-    quote do
-      fn entry, acc(head, bool, tail) = original ->
+      fn entry, acc(h, bool, t) = orig ->
         if bool and unquote(callback).(entry) do
-          skip(original)
+          skip(orig)
         else
-          next_with_acc(unquote(fun), entry, head, false, tail)
+          next_with_acc(unquote(f), entry, h, false, t)
         end
       end
     end
   end
 
-  defmacro filter(callback, fun \\ nil) do
+  defmacro filter(callback, f \\ nil) do
     quote do
-      fn entry, acc ->
+      fn(entry, acc) ->
         if unquote(callback).(entry) do
-          next(unquote(fun), entry, acc)
+          next(unquote(f), entry, acc)
         else
           skip(acc)
         end
@@ -115,11 +88,11 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro filter_map(filter, mapper, fun \\ nil) do
+  defmacro filter_map(filter, mapper, f \\ nil) do
     quote do
-      fn entry, acc ->
+      fn(entry, acc) ->
         if unquote(filter).(entry) do
-          next(unquote(fun), unquote(mapper).(entry), acc)
+          next(unquote(f), unquote(mapper).(entry), acc)
         else
           skip(acc)
         end
@@ -127,30 +100,19 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro map(callback, fun \\ nil) do
+  defmacro map(callback, f \\ nil) do
     quote do
-      fn entry, acc ->
-        next(unquote(fun), unquote(callback).(entry), acc)
+      fn(entry, acc) ->
+        next(unquote(f), unquote(callback).(entry), acc)
       end
     end
   end
 
-  defmacro map_every(nth, mapper, fun \\ nil) do
+  defmacro reject(callback, f \\ nil) do
     quote do
-      fn
-        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
-          next_with_acc(unquote(fun), unquote(mapper).(entry), head, 1, tail)
-        entry, acc(head, curr, tail) ->
-          next_with_acc(unquote(fun), entry, head, curr + 1, tail)
-      end
-    end
-  end
-
-  defmacro reject(callback, fun \\ nil) do
-    quote do
-      fn entry, acc ->
+      fn(entry, acc) ->
         unless unquote(callback).(entry) do
-          next(unquote(fun), entry, acc)
+          next(unquote(f), entry, acc)
         else
           skip(acc)
         end
@@ -158,59 +120,62 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro scan2(callback, fun \\ nil) do
+  defmacro scan_2(callback, f \\ nil) do
     quote do
       fn
-        entry, acc(head, :first, tail) ->
-          next_with_acc(unquote(fun), entry, head, {:ok, entry}, tail)
-        entry, acc(head, {:ok, acc}, tail) ->
+        entry, acc(h, :first, t) ->
+          next_with_acc(unquote(f), entry, h, {:ok, entry}, t)
+        entry, acc(h, {:ok, acc}, t) ->
           value = unquote(callback).(entry, acc)
-          next_with_acc(unquote(fun), value, head, {:ok, value}, tail)
+          next_with_acc(unquote(f), value, h, {:ok, value}, t)
       end
     end
   end
 
-  defmacro scan3(callback, fun \\ nil) do
+  defmacro scan_3(callback, f \\ nil) do
     quote do
-      fn entry, acc(head, acc, tail) ->
+      fn(entry, acc(h, acc, t)) ->
         value = unquote(callback).(entry, acc)
-        next_with_acc(unquote(fun), value, head, value, tail)
+        next_with_acc(unquote(f), value, h, value, t)
       end
     end
   end
 
-  defmacro take(fun \\ nil) do
+  defmacro take(f \\ nil) do
     quote do
-      fn entry, acc(head, curr, tail) = original ->
-        case curr do
+      fn(entry, acc(h, n, t) = orig) ->
+        case n do
           0 ->
-            {:halt, original}
+            {:halt, orig}
           1 ->
-            {_, acc} = next_with_acc(unquote(fun), entry, head, 0, tail)
-            {:halt, acc}
+            case next_with_acc(unquote(f), entry, h, n-1, t) do
+              {:cont, acc} -> {:halt, acc}
+              reason -> reason
+            end
           _ ->
-            next_with_acc(unquote(fun), entry, head, curr - 1, tail)
+            next_with_acc(unquote(f), entry, h, n-1, t)
         end
       end
     end
   end
 
-  defmacro take_every(nth, fun \\ nil) do
+  defmacro take_every(nth, f \\ nil) do
     quote do
       fn
-        entry, acc(head, curr, tail) when curr in [unquote(nth), :first] ->
-          next_with_acc(unquote(fun), entry, head, 1, tail)
-        entry, acc(head, curr, tail) ->
-          skip(acc(head, curr + 1, tail))
+        entry, acc(h, n, t) when n === :first
+                            when n === unquote(nth) ->
+          next_with_acc(unquote(f), entry, h, 1, t)
+        entry, acc(h, n, t) ->
+          skip(acc(h, n+1, t))
       end
     end
   end
 
-  defmacro take_while(callback, fun \\ nil) do
+  defmacro take_while(callback, f \\ nil) do
     quote do
-      fn entry, acc ->
+      fn(entry, acc) ->
         if unquote(callback).(entry) do
-          next(unquote(fun), entry, acc)
+          next(unquote(f), entry, acc)
         else
           {:halt, acc}
         end
@@ -218,23 +183,23 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro uniq_by(callback, fun \\ nil) do
+  defmacro uniq(callback, f \\ nil) do
     quote do
-      fn entry, acc(head, prev, tail) = original ->
+      fn(entry, acc(h, prev, t) = acc) ->
         value = unquote(callback).(entry)
         if Map.has_key?(prev, value) do
-          skip(original)
+          skip(acc)
         else
-          next_with_acc(unquote(fun), entry, head, Map.put(prev, value, true), tail)
+          next_with_acc(unquote(f), entry, h, Map.put(prev, value, true), t)
         end
       end
     end
   end
 
-  defmacro with_index(fun \\ nil) do
+  defmacro with_index(f \\ nil) do
     quote do
-      fn entry, acc(head, counter, tail) ->
-        next_with_acc(unquote(fun), {entry, counter}, head, counter + 1, tail)
+      fn(entry, acc(h, counter, t)) ->
+        next_with_acc(unquote(f), {entry, counter}, h, counter + 1, t)
       end
     end
   end

lib/elixir/lib/string/chars.ex

@@ -3,23 +3,18 @@ import Kernel, except: [to_string: 1]
 defprotocol String.Chars do
   @moduledoc ~S"""
   The `String.Chars` protocol is responsible for
-  converting a structure to a binary (only if applicable).
-
+  converting a structure to a Binary (only if applicable).
   The only function required to be implemented is
-  `to_string/1`, which does the conversion.
+  `to_string` which does the conversion.
 
-  The `to_string/1` function automatically imported
-  by `Kernel` invokes this protocol. String
-  interpolation also invokes `to_string/1` in its
+  The `to_string` function automatically imported
+  by Kernel invokes this protocol. String
+  interpolation also invokes `to_string` in its
   arguments. For example, `"foo#{bar}"` is the same
   as `"foo" <> to_string(bar)`.
   """
 
-  @doc """
-  Converts `term` to a string.
-  """
-  @spec to_string(t) :: String.t
-  def to_string(term)
+  def to_string(thing)
 end
 
 defimpl String.Chars, for: Atom do
@@ -33,30 +28,30 @@ defimpl String.Chars, for: Atom do
 end
 
 defimpl String.Chars, for: BitString do
-  def to_string(term) when is_binary(term) do
-    term
+  def to_string(thing) when is_binary(thing) do
+    thing
   end
 
-  def to_string(term) do
+  def to_string(thing) do
     raise Protocol.UndefinedError,
              protocol: @protocol,
-                value: term,
+                value: thing,
           description: "cannot convert a bitstring to a string"
   end
 end
 
 defimpl String.Chars, for: List do
-  def to_string(charlist), do: List.to_string(charlist)
+  def to_string(char_list), do: List.to_string(char_list)
 end
 
 defimpl String.Chars, for: Integer do
-  def to_string(term) do
-    Integer.to_string(term)
+  def to_string(thing) do
+    Integer.to_string(thing)
   end
 end
 
 defimpl String.Chars, for: Float do
-  def to_string(term) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
+  def to_string(thing) do
+    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
   end
 end

lib/elixir/lib/string_io.ex

@@ -1,9 +1,6 @@
 defmodule StringIO do
   @moduledoc """
-  Controls an IO device process that wraps a string.
-
-  A `StringIO` IO device can be passed as a "device" to
-  most of the functions in the `IO` module.
+  This module provides an IO device that wraps a string.
 
   ## Examples
 
@@ -18,9 +15,6 @@ defmodule StringIO do
   @doc """
   Creates an IO device.
 
-  `string` will be the initial input of the newly created
-  device.
-
   If the `:capture_prompt` option is set to `true`,
   prompts (specified as arguments to `IO.get*` functions)
   are captured.
@@ -40,14 +34,13 @@ defmodule StringIO do
       {"", ">"}
 
   """
-  @spec open(binary, keyword) :: {:ok, pid}
+  @spec open(binary, Keyword.t) :: {:ok, pid}
   def open(string, options \\ []) when is_binary(string) do
     GenServer.start_link(__MODULE__, {string, options}, [])
   end
 
   @doc """
-  Returns the current input/output buffers for the given IO
-  device.
+  Returns current buffers.
 
   ## Examples
 
@@ -63,7 +56,7 @@ defmodule StringIO do
   end
 
   @doc """
-  Flushes the output buffer and returns its current contents.
+  Flushes output buffer.
 
   ## Examples
 
@@ -81,8 +74,7 @@ defmodule StringIO do
   end
 
   @doc """
-  Stops the IO device and returns the remaining input/output
-  buffers.
+  Stops the IO device and returns remaining buffers.
 
   ## Examples
 
@@ -135,20 +127,21 @@ defmodule StringIO do
     s
   end
 
-  defp io_request({:put_chars, chars} = req, s) do
-    put_chars(:latin1, chars, req, s)
+  defp io_request({:put_chars, chars}, %{output: output} = s) do
+    {:ok, %{s | output: <<output::binary, IO.chardata_to_string(chars)::binary>>}}
   end
 
-  defp io_request({:put_chars, m, f, as} = req, s) do
-    put_chars(:latin1, apply(m, f, as), req, s)
+  defp io_request({:put_chars, m, f, as}, %{output: output} = s) do
+    chars = apply(m, f, as)
+    {:ok, %{s | output: <<output::binary, IO.chardata_to_string(chars)::binary>>}}
   end
 
-  defp io_request({:put_chars, encoding, chars} = req, s) do
-    put_chars(encoding, chars, req, s)
+  defp io_request({:put_chars, _encoding, chars}, s) do
+    io_request({:put_chars, chars}, s)
   end
 
-  defp io_request({:put_chars, encoding, mod, func, args} = req, s) do
-    put_chars(encoding, apply(mod, func, args), req, s)
+  defp io_request({:put_chars, _encoding, mod, func, args}, s) do
+    io_request({:put_chars, mod, func, args}, s)
   end
 
   defp io_request({:get_chars, prompt, n}, s) when n >= 0 do
@@ -203,25 +196,19 @@ defmodule StringIO do
     {{:error, :request}, s}
   end
 
-  ## put_chars
-
-  defp put_chars(encoding, chars, req, %{output: output} = s) do
-    case :unicode.characters_to_binary(chars, encoding, :unicode) do
-      string when is_binary(string) ->
-        {:ok, %{s | output: output <> string}}
-      {_, _, _} ->
-        {{:error, req}, s}
-    end
-  end
-
   ## get_chars
 
-  defp get_chars(encoding, prompt, n, %{input: input} = s) do
+  defp get_chars(encoding, prompt, n,
+                 %{input: input, output: output, capture_prompt: capture_prompt} = s) do
     case do_get_chars(input, encoding, n) do
       {:error, _} = error ->
         {error, s}
       {result, input} ->
-        {result, state_after_read(s, input, prompt)}
+        if capture_prompt do
+          output = <<output::binary, IO.chardata_to_string(prompt)::binary>>
+        end
+
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -255,86 +242,88 @@ defmodule StringIO do
 
   ## get_line
 
-  defp get_line(encoding, prompt, %{input: input} = s) do
-    case bytes_until_eol(input, encoding, 0) do
-      {:split, 0} ->
-        {:eof, state_after_read(s, "", prompt)}
-      {:split, count} ->
-        {result, remainder} = :erlang.split_binary(input, count)
+  defp get_line(encoding, prompt,
+                %{input: input, output: output, capture_prompt: capture_prompt} = s) do
+    case :unicode.characters_to_list(input, encoding) do
+      {:error, _, _} ->
+        {{:error, :collect_line}, s}
+      {:incomplete, _, _} ->
+        {{:error, :collect_line}, s}
+      chars ->
+        {result, input} = do_get_line(chars, encoding)
 
-        {result, state_after_read(s, remainder, prompt)}
-      {:replace_split, count} ->
-        {result, remainder} = :erlang.split_binary(input, count)
+        if capture_prompt do
+          output = <<output::binary, IO.chardata_to_string(prompt)::binary>>
+        end
 
-        {binary_part(result, 0, byte_size(result) - 2) <> "\n", state_after_read(s, remainder, prompt)}
-      :error
-        -> {{:error, :collect_line}, s}
+        {result, %{s | input: input, output: output}}
     end
   end
 
+  defp do_get_line('', _encoding) do
+    {:eof, ""}
+  end
+
+  defp do_get_line(chars, encoding) do
+    {line, rest} = collect_line(chars)
+    {:unicode.characters_to_binary(line, encoding),
+      :unicode.characters_to_binary(rest, encoding)}
+  end
+
   ## get_until
 
-  defp get_until(encoding, prompt, mod, fun, args, %{input: input} = s) do
-    case do_get_until(input, encoding, mod, fun, args) do
-      {result, input, count} ->
-        input =
-         case input do
-           :eof -> ""
-           _ -> list_to_binary(input, encoding)
-         end
-
-        {get_until_result(result, encoding), state_after_read(s, input, prompt, count)}
-
-      :error ->
+  defp get_until(encoding, prompt, mod, fun, args,
+                 %{input: input, output: output, capture_prompt: capture_prompt} = s) do
+    case :unicode.characters_to_list(input, encoding) do
+      {:error, _, _} ->
         {:error, s}
+      {:incomplete, _, _} ->
+        {:error, s}
+      chars ->
+        {result, input, count} = do_get_until(chars, encoding, mod, fun, args)
+
+        if capture_prompt do
+          output = <<output::binary, :binary.copy(IO.chardata_to_string(prompt), count)::binary>>
+        end
+
+        input =
+          case input do
+            :eof -> ""
+            _ -> :unicode.characters_to_binary(input, encoding)
+          end
+
+        {result, %{s | input: input, output: output}}
     end
   end
 
   defp do_get_until(chars, encoding, mod, fun, args, continuation \\ [], count \\ 0)
 
-  defp do_get_until("", encoding, mod, fun, args, continuation, count) do
+  defp do_get_until('', encoding, mod, fun, args, continuation, count) do
     case apply(mod, fun, [continuation, :eof | args]) do
       {:done, result, rest} ->
         {result, rest, count + 1}
       {:more, next_continuation} ->
-        do_get_until("", encoding, mod, fun, args, next_continuation, count + 1)
+        do_get_until('', encoding, mod, fun, args, next_continuation, count + 1)
     end
   end
 
   defp do_get_until(chars, encoding, mod, fun, args, continuation, count) do
-    case bytes_until_eol(chars, encoding, 0) do
-      {r, c} when r in [:split, :replace_split] ->
-        {line, rest} = :erlang.split_binary(chars, c)
+    {line, rest} = collect_line(chars)
 
-        case apply(mod, fun, [continuation, binary_to_list(line, encoding) | args]) do
-          {:done, result, :eof} ->
-            {result, rest, count + 1}
-          {:done, result, extra} ->
-            {result, extra ++ binary_to_list(rest, encoding), count + 1}
-          {:more, next_continuation} ->
-            do_get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
+    case apply(mod, fun, [continuation, line | args]) do
+      {:done, result, rest1} ->
+        unless rest1 == :eof do
+          rest = rest1 ++ rest
         end
-
-      :error ->
-        :error
+        {result, rest, count + 1}
+      {:more, next_continuation} ->
+        do_get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
     end
   end
 
-  defp binary_to_list(l, _)        when is_list(l),   do: l
-  defp binary_to_list(b, :unicode) when is_binary(b), do: to_charlist(b)
-  defp binary_to_list(b, :latin1)  when is_binary(b), do: :binary.bin_to_list(b)
-  defp list_to_binary(b, _)        when is_binary(b), do: b
-  defp list_to_binary(l, :unicode) when is_list(l),   do: to_string(l)
-  defp list_to_binary(l, :latin1)  when is_list(l),   do: :binary.list_to_bin(l)
-
-  # From http://erlang.org/doc/apps/stdlib/io_protocol.html: Result can be any
-  # Erlang term, but if it is a list(), the I/O server can convert it to a binary().
-  defp get_until_result(l, encoding) when is_list(l), do: list_to_binary(l, encoding)
-  defp get_until_result(other, _), do: other
-
   ## io_requests
 
-  defp io_requests([r | rs], {:ok, s}) do
+  defp io_requests([r|rs], {:ok, s}) do
     io_requests(rs, io_request(r, s))
   end
 
@@ -344,29 +333,25 @@ defmodule StringIO do
 
   ## helpers
 
-  defp state_after_read(state, remainder, prompt, count \\ 1)
-
-  defp state_after_read(%{capture_prompt: false} = s, remainder, _prompt, _count) do
-    %{s | input: remainder}
+  defp collect_line(chars) do
+    collect_line(chars, [])
   end
 
-  defp state_after_read(%{capture_prompt: true, output: output} = s, remainder, prompt, count) do
-    %{s | input: remainder, output: <<output::binary, :binary.copy(IO.chardata_to_string(prompt), count)::binary>>}
+  defp collect_line([], stack) do
+    {:lists.reverse(stack), []}
   end
 
-  defp bytes_until_eol("", _, count), do: {:split, count}
-  defp bytes_until_eol(<<"\r\n"::binary, _::binary>>, _, count), do: {:replace_split, count + 2}
-  defp bytes_until_eol(<<"\n"::binary, _::binary>>, _, count), do: {:split, count + 1}
-
-  defp bytes_until_eol(<<head::utf8, tail::binary>>, :unicode, count) do
-    bytes_until_eol(tail, :unicode, count + byte_size(<<head::utf8>>))
+  defp collect_line([?\r, ?\n | rest], stack) do
+    {:lists.reverse([?\n|stack]), rest}
   end
 
-  defp bytes_until_eol(<<_, tail::binary>>, :latin1, count) do
-    bytes_until_eol(tail, :latin1, count + 1)
+  defp collect_line([?\n | rest], stack) do
+    {:lists.reverse([?\n|stack]), rest}
   end
 
-  defp bytes_until_eol(<<_::binary>>, _, _), do: :error
+  defp collect_line([h|t], stack) do
+    collect_line(t, [h|stack])
+  end
 
   defp io_reply(from, reply_as, reply) do
     send from, {:io_reply, reply_as, reply}

lib/elixir/lib/supervisor/default.ex

@@ -1,7 +1,13 @@
 defmodule Supervisor.Default do
   @moduledoc false
+  @behaviour :supervisor
 
-  def init({children, opts}) do
-    Supervisor.init(children, opts)
+  @doc """
+  Supervisor callback that simply returns the given args.
+
+  This is the supervisor used by `Supervisor.start_link/2`.
+  """
+  def init(args) do
+    args
   end
-end
+end

lib/elixir/lib/supervisor/spec.ex

@@ -1,15 +1,11 @@
 defmodule Supervisor.Spec do
   @moduledoc """
-  NOTE: The functions in this module are deprecated and they do not
-  work with the module-based child specs introduced in Elixir v1.5.
-  Please see the `Supervisor` documentation instead.
-
-  Convenience functions for defining supervisor specifications.
+  Convenience functions for defining a supervision specification.
 
   ## Example
 
-  By using the functions in this module one can specify the children
-  to be used under a supervisor, started with `Supervisor.start_link/2`:
+  By using the functions in this module one can define a supervisor
+  and start it with `Supervisor.start_link/2`:
 
       import Supervisor.Spec
 
@@ -20,7 +16,7 @@ defmodule Supervisor.Spec do
 
       Supervisor.start_link(children, strategy: :one_for_one)
 
-  Sometimes, it may be handy to define supervisors backed
+  In many situations, it may be handy to define supervisors backed
   by a module:
 
       defmodule MySupervisor do
@@ -41,35 +37,42 @@ defmodule Supervisor.Spec do
 
   Notice in this case we don't have to explicitly import
   `Supervisor.Spec` as `use Supervisor` automatically does so.
-  Defining a module-based supervisor can be useful, for example,
-  to perform initialization tasks in the `c:init/1` callback.
+
+  Explicit supervisors as above are required when there is a need to:
+
+    1. Partially change the supervision tree during hot-code swaps.
+
+    2. Define supervisors inside other supervisors.
+
+    3. Perform actions inside the supervision `init/1` callback.
+
+       For example, you may want to start an ETS table that is linked to
+       the supervisor (i.e. if the supervision tree needs to be restarted,
+       the ETS table must be restarted too).
 
   ## Supervisor and worker options
 
-  In the example above, we defined specs for workers and supervisors.
-  These specs (both for workers as well as supervisors) accept the
-  following options:
+  In the example above, we defined workers and supervisors
+  and each accepts the following options:
 
     * `:id` - a name used to identify the child specification
       internally by the supervisor; defaults to the given module
-      name for the child worker/supervisor
+      name
 
     * `:function` - the function to invoke on the child to start it
 
-    * `:restart` - an atom that defines when a terminated child process should
-      be restarted (see the "Restart values" section below)
+    * `:restart` - defines when a terminated child process should be restarted
 
-    * `:shutdown` - an atom that defines how a child process should be
-      terminated (see the "Shutdown values" section below)
+    * `:shutdown` - defines how a child process should be terminated
 
     * `:modules` - it should be a list with one element `[module]`,
       where module is the name of the callback module only if the
       child process is a `Supervisor` or `GenServer`; if the child
-      process is a `GenEvent`, `:modules` should be `:dynamic`
+      process is a `GenEvent`, modules should be `:dynamic`
 
   ### Restart values (:restart)
 
-  The following restart values are supported in the `:restart` option:
+  The following restart values are supported:
 
     * `:permanent` - the child process is always restarted
 
@@ -77,36 +80,27 @@ defmodule Supervisor.Spec do
       when the supervisor's strategy is `:rest_for_one` or `:one_for_all`)
 
     * `:transient` - the child process is restarted only if it
-      terminates abnormally, i.e., with an exit reason other than
+      terminates abnormally, i.e. with another exit reason than
       `:normal`, `:shutdown` or `{:shutdown, term}`
 
-  Notice that supervisor that reached maximum restart intensity will exit with `:shutdown` reason.
-  In this case the supervisor will only be restarted if its child specification was defined with
-  the `:restart` option is set to `:permanent` (the default).
-
   ### Shutdown values (:shutdown)
 
-  The following shutdown values are supported in the `:shutdown` option:
+  The following shutdown values are supported:
 
     * `:brutal_kill` - the child process is unconditionally terminated
-      using `Process.exit(child, :kill)`
+      using `exit(child, :kill)`.
 
     * `:infinity` - if the child process is a supervisor, this is a mechanism
-      to give the subtree enough time to shutdown; it can also be used with
-      workers with care
-
-    * any integer - the value of `:shutdown` can also be any integer meaning
-      that the supervisor tells the child process to terminate by calling
-      `Process.exit(child, :shutdown)` and then waits for an exit signal back.
-      If no exit signal is received within the specified time (the value of this
-      option, in milliseconds), the child process is unconditionally terminated
-      using `Process.exit(child, :kill)`
+      to give the subtree enough time to shutdown. It can also be used with
+      workers with care.
 
+    * Finally, the value can also be any integer meaning that the supervisor tells
+      the child process to terminate by calling `Process.exit(child, :shutdown)`
+      and then waits for an exit signal back. If no exit signal is received
+      within the specified time (in milliseconds), the child process is
+      unconditionally terminated using `Process.exit(child, :kill)`.
   """
 
-  # TODO: Deprecate all functions in this module on Elixir v1.8.
-  # Also deprecate entry in Supervisor.Default.
-
   @typedoc "Supported strategies"
   @type strategy :: :simple_one_for_one | :one_for_one | :one_for_all | :rest_for_one
 
@@ -114,7 +108,7 @@ defmodule Supervisor.Spec do
   @type restart :: :permanent | :transient | :temporary
 
   @typedoc "Supported shutdown values"
-  @type shutdown :: timeout | :brutal_kill
+  @type shutdown :: :brutal_kill | :infinity | non_neg_integer
 
   @typedoc "Supported worker values"
   @type worker :: :worker | :supervisor
@@ -137,13 +131,11 @@ defmodule Supervisor.Spec do
   Receives a list of children (workers or supervisors) to
   supervise and a set of options.
 
-  Returns a tuple containing the supervisor specification. This tuple can be
-  used as the return value of the `c:init/1` callback when implementing a
-  module-based supervisor.
+  Returns a tuple containing the supervisor specification.
 
   ## Examples
 
-      supervise(children, strategy: :one_for_one)
+      supervise children, strategy: :one_for_one
 
   ## Options
 
@@ -153,18 +145,18 @@ defmodule Supervisor.Spec do
       in the `Supervisor` module docs.
 
     * `:max_restarts` - the maximum amount of restarts allowed in
-      a time frame. Defaults to `3`.
+      a time frame. Defaults to 3.
 
     * `:max_seconds` - the time frame in which `:max_restarts` applies.
-      Defaults to `5`.
+      Defaults to 5.
 
-  The `:strategy` option is required and by default a maximum of 3 restarts is
-  allowed within 5 seconds. Check the `Supervisor` module for a detailed
-  description of the available strategies.
+  The `:strategy` option is required and by default maximum 3 restarts
+  are allowed within 5 seconds. Please check the `Supervisor` module for
+  a complete description of the available strategies.
   """
   @spec supervise([spec], strategy: strategy,
                           max_restarts: non_neg_integer,
-                          max_seconds: pos_integer) :: {:ok, tuple}
+                          max_seconds: non_neg_integer) :: {:ok, tuple}
   def supervise(children, options) do
     unless strategy = options[:strategy] do
       raise ArgumentError, "expected :strategy option to be given"
@@ -173,22 +165,11 @@ defmodule Supervisor.Spec do
     maxR = Keyword.get(options, :max_restarts, 3)
     maxS = Keyword.get(options, :max_seconds, 5)
 
-    assert_unique_ids(Enum.map(children, &get_id/1))
+    assert_unique_ids(Enum.map(children, &elem(&1, 0)))
     {:ok, {{strategy, maxR, maxS}, children}}
   end
 
-  defp get_id({id, _, _, _, _, _}) do
-    id
-  end
-  defp get_id(other) do
-    raise ArgumentError,
-      "invalid tuple specification given to supervise/2. If you are trying to use " <>
-      "the map child specification that is part of the Elixir v1.5, use Supervisor.init/2 " <>
-      "instead of Supervisor.Spec.supervise/2. See the Supervisor module for more information. " <>
-      "Got: #{inspect other}"
-  end
-
-  defp assert_unique_ids([id | rest]) do
+  defp assert_unique_ids([id|rest]) do
     if id in rest do
       raise ArgumentError,
         "duplicated id #{inspect id} found in the supervisor specification, " <>
@@ -206,7 +187,7 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a worker which will be started
   with the given arguments.
 
-      worker(ExUnit.Runner, [], restart: :permanent)
+      worker ExUnit.Runner, [], restart: :permanent
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
@@ -217,8 +198,8 @@ defmodule Supervisor.Spec do
        shutdown: 5000,
        modules: [module]]
 
-  Check the documentation for the `Supervisor.Spec` module for more
-  information on the options.
+  Check `Supervisor.Spec` module docs for more information on
+  the options.
   """
   @spec worker(module, [term], [restart: restart, shutdown: shutdown,
                                 id: term, function: atom, modules: modules]) :: spec
@@ -230,7 +211,7 @@ defmodule Supervisor.Spec do
   Defines the given `module` as a supervisor which will be started
   with the given arguments.
 
-      supervisor(ExUnit.Runner, [], restart: :permanent)
+      supervisor ExUnit.Runner, [], restart: :permanent
 
   By default, the function `start_link` is invoked on the given
   module. Overall, the default values for the options are:
@@ -241,8 +222,8 @@ defmodule Supervisor.Spec do
        shutdown: :infinity,
        modules: [module]]
 
-  Check the documentation for the `Supervisor.Spec` module for more
-  information on the options.
+  Check `Supervisor.Spec` module docs for more information on
+  the options.
   """
   @spec supervisor(module, [term], [restart: restart, shutdown: shutdown,
                                     id: term, function: atom, modules: modules]) :: spec