Release v1.2.2

Closes #4228

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

CHANGELOG.md

@@ -1,405 +1,225 @@
-# Changelog for Elixir v1.3
+# Changelog for Elixir v1.2
 
-Elixir v1.3 brings many improvements to the language, the compiler and its tooling, specially Mix (Elixir's build tool) and ExUnit (Elixir's test framework).
+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.
+
+## Erlang 18 support
+
+We have brought many features specific to Erlang 18. Here are the highlights:
+
+  * 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
 
 ## Language improvements
 
-The language has been improved semantically and includes new types and APIs. Let's see the three major features.
+This release includes four notable language improvements:
 
-### Deprecation of imperative assignment
+  * The addition of multi aliases/imports/require:
 
-Elixir will now warn if constructs like `if`, `case` and friends assign to a variable that is accessed in an outer scope. As an example, imagine a function called `format` that receives a message and some options and it must return a path alongside the message:
+        alias MyApp.{Foo, Bar, Baz}
 
-```elixir
-def format(message, opts) do
-  path =
-    if (file = opts[:file]) && (line = opts[:line]) do
-      relative = Path.relative_to_cwd(file)
-      message  = Exception.format_file_line(relative, line) <> " " <> message
-      relative
-    end
+  * Support for variables in map keys:
 
-  {path, message}
-end
-```
+        %{key => value}
 
-The `if` block above is implicitly changing the value in `message`. Now imagine we want to move the `if` block to its own function to clean up the implementation:
+  * Support for the pin operator in map keys and function clauses:
 
-```elixir
-def format(message, opts) do
-  path = with_file_and_line(message, opts)
-  {path, message}
-end
+        %{^key => value} = %{key => value}
+        fn ^key -> :ok end
 
-defp with_file_and_line(message, opts) do
-  if (file = opts[:file]) && (line = opts[:line]) do
-    relative = Path.relative_to_cwd(file)
-    message  = Exception.format_file_line(relative, line) <> " " <> message
-    relative
-  end
-end
-```
+  * Addition of the `with` special form to match on multiple expressions:
 
-The refactored version is broken because the `if` block was actually returning two values, the relative path *and* the new message. Elixir v1.3 will warn on such cases, forcing both variables to be explicitly returned from `if`, `case` and other constructs. Furthermore, this change gives us the opportunity to unify the language scoping rules in future releases.
+        with {:ok, contents} <- File.read("my_file.ex"),
+             {res, binding} <- Code.eval_string(contents),
+             do: {:ok, res}
 
-### Calendar types and sigils
+These improvements aim to make the language more consistent and expressive.
 
-Elixir v1.3 introduces the `Calendar` module as well as 4 new calendar types:
+## Getting started experience
 
-  * `Date` - used to store dates (year, month, day) in a given calendar
-  * `Time` - used to store time (hour, minute, second, microseconds)
-  * `NaiveDateTime` - used to store datetimes without a timezone (year, month, day, hour, minute, second, microseconds) in a given calendar. It is called naïve because without a timezone, the datetime may not actually exist. For example, when there are daylight savings changes, a whole hour may not exist (when the clock moves forward) or a particular instant may happen twice (when the clock moves backwards)
-  * `DateTime` - used to store datetimes with timezone (year, month, day, hour, minute, second, microsecond and time zone, with abbreviation, UTC and standard offset)
+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.
 
-The current Calendar modules and its types is to provide a base for interoperatibility in the ecosystem instead of full-featured datetime API. This release includes basic functionality for building new types and converting them from and back strings.
+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.
 
-Elixir v1.3 also introduces 3 new sigils related to the types above:
+## Workflow improvements
 
-  * `~D[2016-05-29]` - builds a new date
-  * `~T[08:00:00]` and `~T[08:00:00.285]` - builds a new time (with different precisions)
-  * `~N[2016-05-29 08:00:00]` - builds a naive date time
+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:
 
-### Access selectors
+    build_path: "../../_build",
+    config_path: "../../config/config.exs",
 
-This release introduces new accessors to make it simpler for developers to traverse nested data structures, traversing and updating data in different ways.  For instance, given a user with a list of languages, here is how to deeply traverse the map and convert all language names to uppercase:
+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.
 
-```iex
-iex> user = %{name: "john",
-...>          languages: [%{name: "elixir", type: :functional},
-...>                      %{name: "c", type: :procedural}]}
-iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
-%{name: "john",
-  languages: [%{name: "ELIXIR", type: :functional},
-              %{name: "C", type: :procedural}]}
-```
+These are great additions on top of the faster compilation times we have
+achieved when migrating to Erlang 18.
 
-You can see the new accessors in the `Access` module.
+## Rebar 3 support
 
-## Mix
+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.
 
-Mix includes new tasks to improve your everyday workflow. Some of those tasks relies on many compiler improvements to know more about your code, providing static analysis to find possible bugs in your code and faster compilation cycles.
-
-### Compiling n files
-
-Mix no longer announces every file it compiles. Instead it outputs how many files there is to compile per compilers. Here is the output for a project like [`gettext`](https://github.com/elixir-lang/gettext):
-
-```
-Compiling 1 file (.yrl)
-Compiling 1 file (.erl)
-Compiling 19 files (.ex)
-Generated gettext app
-```
-
-In case a file is taking too long to compile, Mix will announce such, for example:
-
-```
-Compiling lib/gettext.ex (it's taking more than 5s)
-```
-
-The goal of these changes is to put an increased focus on the "warnings" emitted by the compiler.
-
-In any case, the previous behaviour can be brought back with the `--verbose` flag and the compilation threshold for files that are taking long can be set via the `--long-compilation-threshold` option.
-
-### mix xref
-
-Speaking about warnings, Mix v1.3 includes a new task called `xref` that performs cross reference checks in your code. One of such checks is the ability to find calls to modules and functions that do not exist. For example, if in your library code you call `ThisModuleDoesNotExist.foo(1, 2, 3)`, `mix xref unreachable` will be able to find such code and let you know about it.
-
-Since such checks can discover possible bugs in your codebase, a new compiler called `xref` has been added to `Mix.compilers/0`, so they run by default every time you compile your code.
-
-We have included other modes in `xref`, such as `mix xref callers Foo`, to find all places in your code that a function from the module `Foo` is called. We hope other tools and text editors can leverage such features to provide useful functionality for their users.
-
-### Better dependency tracking
-
-Besides `xref`, Elixir v1.3 provides better module tracking generally. For example, in previous versions, if you changed a `:path` dependency, Elixir would always fully recompile the current project. In this release, we have improved the tracking algorithms such that, if you change a `:path` dependency, only the files that depend on such dependency are recompiled.
-
-Such improvements do not only make compilation faster but they also make working with umbrella applications much more productive. Previously, changing a sibling application triggered a full project recompilation, now Elixir can track between sibling applications and recompile only what is needed.
-
-### mix app.tree and deps.tree
-
-Mix also includes both `mix app.tree` and `mix deps.tree`. The first will list all applications your current project needs to start in order to boot (i.e. the ones listed in `application/0` in your `mix.exs`) while the second will lists all of your dependencies and so on recursively.
-
-Here is a quick example from [Plug](https://github.com/elixir-lang/plug):
-
-```elixir
-$ mix app.tree
-plug
-├── elixir
-├── crypto
-├── logger
-│   └── elixir
-└── mime
-    └── elixir
-```
-
-### mix escript.install
-
-Mix also includes `mix escript.install` and `mix escript.uninstall` tasks for managing escripts. The tasks was designed in a way to mimic the existing `mix archive` functionality except that:
-
-  * Archives must be used sparingly because every new archive installed affects Mix performance, as every new archive is loaded when Mix boots. Escripts solve this by being managed apart from your Elixir/Mix installed
-  * Archives depends on the current Elixir version. Therefore, updating your Elixir version may break an archive. Fortunately, escripts include Elixir inside themselves, and therefore do not depend on your Elixir system version
-
-Escripts will be installed at `~/.mix/escripts` which must be added to your [`PATH` environment variable](https://en.wikipedia.org/wiki/PATH_(variable)).
-
-### Option parser integration
-
-Elixir v1.3 includes improvements to the option parser, including `OptionParser.parse!/2` and `OptionParser.parse_head!/2` functions that will raise in case of invalid or unknown switches. Mix builds on top of this functionality to provide automatic error reporting solving a common complaint where invalid options were not reported by Mix tasks.
-
-For example, invoking `mix test --unknown` in earlier Elixir versions would silently discard the `--unknown` option. Now `mix test` correctly reports such errors:
-
-```
-$ mix test --unknown
-** (Mix) Could not invoke task "test": 1 error found!
---unknown : Unknown option
-```
-
-Note not all tasks have been updated to use strict option parsing. Some tasks, like `mix compile`, are actually a front-end to many other tasks, and as such, it cannot effectively assert which options are valid.
-
-## ExUnit
-
-ExUnit packs many improvements on the tooling side, better integration with external tools, as well as mechanisms to improve the readability of your tests.
-
-### mix test --stale
-
-ExUnit builds on top of `mix xref` to provide the `mix test --stale` functionality. When the `--stale` flag is given, `mix` will only run the tests that may have changed since the last time you ran `mix test --stale`. For example:
-
-  * If you saved a test file on disk, Mix will run that file and ignore the ones that have not changed
-  * If you changed a library file, for example, `lib/foo.ex` that defines `Foo`, any test that invokes a function in `Foo` directly or indirectly will also run
-  * If you modify your `mix.exs` or your `test/test_helper.exs`, Mix will run the whole test suite
-
-This feature provides a great workflow for developers, allowing them to effortlessly focus on parts of the codebase when developing new features.
-
-### Diffing
-
-ExUnit will now include diff-ing output every time a developer asserts `assert left == right` in their tests. For example, the assertion:
-
-```elixir
-assert "fox jumps over the lazy dog" ==
-       "brown fox jumps over the dog"
-```
-
-will fail with
-
-```elixir
-  1) test compare (Difference)
-     lib/ex_unit/examples/difference.exs:10
-     Assertion with == failed
-     lhs:  "fox jumps over the lazy dog"
-     rhs:  "brown fox jumps over the dog"
-     stacktrace:
-       lib/ex_unit/examples/difference.exs:11: (test)
-```
-
-in a way that "lazy" in "lhs" will be shown in red to denote it has been removed from "rhs" while "brown" in "rhs" will be shown in green to denote it has been added to the "rhs".
-
-When working with large or nested data structures, the diffing algorithm makes it fast and convenient to spot the actual differences in the asserted values.
-
-### Test types
-
-ExUnit v1.3 includes the ability to register different test types. This means libraries like QuickCheck can now provide functionality such as:
-
-```elixir
-defmodule StringTest do
-  use ExUnit.Case, async: true
-  use PropertyTestingLibrary
-
-  property "starts_with?" do
-    forall({s1, s2} <- {utf8, utf8}) do
-      String.starts_with?(s1 <> s2, s1)
-    end
-  end
-end
-```
-
-At the end of the run, ExUnit will also report it as a property, including both the amount of tests and properties:
-
-```
-1 property, 10 tests, 0 failures
-```
-
-### Named setups and describes
-
-Finally, ExUnit v1.3 includes the ability to organize tests together in describe blocks:
-
-```elixir
-defmodule StringTest do
-  use ExUnit.Case, async: true
-
-  describe "String.capitalize/2" do
-    test "uppercases the first grapheme" do
-      assert "T" <> _ = String.capitalize("test")
-    end
-
-    test "lowercases the remaining graphemes" do
-      assert "Test" = String.capitalize("TEST")
-    end
-  end
-end
-```
-
-Every test inside a describe block will be tagged with the describe block name. This allows developers to run tests that belong to particular blocks, be them in the same file or across many files:
-
-```
-$ mix test --only describe:"String.capitalize/2"
-```
-
-Note describe blocks cannot be nested. Instead of relying on hierarchy for composition, we want developers to build on top of named setups. For example:
-
-```elixir
-defmodule UserManagementTest do
-  use ExUnit.Case, async: true
-
-  describe "when user is logged in and is an admin" do
-    setup [:log_user_in, :set_type_to_admin]
-
-    test ...
-  end
-
-  describe "when user is logged in and is a manager" do
-    setup [:log_user_in, :set_type_to_manager]
-
-    test ...
-  end
-
-  defp log_user_in(context) do
-    # ...
-  end
-end
-```
-
-By restricting hierarchies in favor of named setups, it is straight-forward for the developer to glance at each describe block and know exactly the setup steps involved.
-
-## v1.3.0 (2016-06-21)
+## v1.2.2
 
 ### 1. Enhancements
 
-#### EEx
-
-  * [EEx.Engine] Support an `init/1` function in engines that will return the initial buffer (defaults to an empty string)
-
-#### Elixir
-
-  * [Access] Add support for `Access.all/0`, `Access.elem/1`, `Access.key/2` and `Access.key!/1` for traversing nested data structures
-  * [Calendar] Add `Calendar` and `Date`, `Time`, `NaiveDateTime` and `DateTime` types
-  * [CLI] Add `--logger-otp-reports BOOL` and `--logger-sasl-reports BOOL` switches
-  * [Compiler] Emit a summary of compilation errors when modules are missing
-  * [Enum] Add `Enum.group_by/3` that allows developers to map on the value being grouped
-  * [Enum] Make list values in maps returned by `Enum.group_by/2` and `Enum.group_by/3` preserve the order of the input enumerable instead of reversing it.
-  * [Enum] Add `Enum.drop_every/2` that drops every `nth`, including the first one
-  * [Exception] Suggest possible functions on `UndefinedFunctionError` for existing modules
-  * [Exception] Warn if unknown fields are given to `raise/2`
-  * [File] Support IO devices in `File.copy/3`
-  * [GenServer] Raise a more meaningful exit if you try to `GenServer.call/3` yourself
-  * [Inspect] Support `:base` option when inspecting binaries
-  * [IO] Add `IO.warn/2` that will print a warning message with stacktrace and notify the compiler a warning was printed (in case --warnings-as-errors was enabled)
-  * [Kernel] Support `generated: true` in quote
-  * [Kernel] Support `Kernel.pop_in/1` and `Kernel.pop_in/2` for yanking a value from a nested data structure
-  * [Kernel] Allow variable struct names when matching, for example, `%module{key: "value"} = struct`
-  * [Kernel] Allow guards on the left side of `<-` in `for` and `with` special forms
-  * [Kernel] Support `else` chunks in `with`
-  * [Kernel] Track `{module, function, arity}` imports and warn on unused ones when such are specified in `:only`
-  * [Kernel] Add `keyword/0` and `keyword/1` built-in types to typespecs
-  * [Kernel] Add sigils for date (`~D[2015-04-17]`), time (`~T[08:00:00]`) and naive date times `~N[2015-04-17 08:00:00]`
-  * [Kernel] Support `@enforce_keys` on `defstruct/1` to guarantee some keys are explicitly given when building structs
-  * [OptionParser] Add support for `:count` switch type
-  * [OptionParser] Add `parse!/2` and `parse_head!/2` that raise `OptionParser.ParseError` in case of errors
-  * [Process] Add `Process.sleep/1`
-  * [Range] `Range.range?/1` now checks the validity of a range.
-  * [Regex] Support `:include_captures` in `Regex.split/3`
-  * [String] Add `String.myers_difference/2` for calculating the difference between two strings
-  * [System] Add `System.os_time/0` and `System.os_time/1`
-  * [Typespec] Add support for `%{required(foo) => bar}` and `%{optional(foo) => bar}` forms (Erlang 19 only)
-  * [Typespec] Add support for `@optional_callbacks` to mark certain that certain callbacks may be optionally implemented
-  * [Typespec] Introduce `%{...}` to mean any map (Erlang 19 only)
-  * [URI] Add `URI.merge/2`
-  * [Version] Add `Version.parse!/1`
-
-#### ExUnit
-
-  * [ExUnit] Show pinned variables on failed `assert ^left = right` and `assert match?(^left, right)` assertions
-  * [ExUnit] Add `ExUnit.Case.register_attribute` which allow attributes to be cleaned up whenever a test is defined
-  * [ExUnit] Add `ExUnit.Case.register_test` and support the ability to tag "tests" by type. This will allow projects like QuickCheck to change the wording in formatters to say "10 properties" instead of "10 tests"
-  * [ExUnit] Support diffing of values when using `==` in `assert`
-  * [ExUnit] Start running tests as soon as cases are loaded. This feature is enabled by default when running tests through Mix
-  * [ExUnit] Raise a straight-forward error message in case a duplicate test name is defined
-  * [ExUnit] Bump the default number of max cases to double of schedulers to support both IO and CPU bound tests
-  * [ExUnit] Support for named setups in `setup` and `setup_all`
-  * [ExUnit] Support for bundling tests together with `describe/2`
-
-#### IEx
-
-  * [IEx] Add `nl/2` that loads a given module on a list of nodes
-  * [IEx.Helpers] No longer restart applications on `recompile/1`
-  * [IEx.Autocomplete] Improve IEx expand to handle functions after `&`
-
-#### Logger
-
-  * [Logger] Introduce `Logger.reset_metadata/0,1`
-
-#### Mix
-
-  * [Mix] Add `mix xref` and `mix compile.xref` that runs cross-reference checks, with the latter running after compilation by default
-  * [Mix] Add `mix app.tree` and `mix deps.tree`
-  * [Mix] Add `Mix.Task.rerun/2` that reenables and re-runs a task
-  * [Mix] Integrate `OptionParser.ParseError` into Mix, automatically converting such exceptions into `Mix.Error` and embedding the task information
-  * [Mix] Support `@preferred_cli_env` attribute when defining tasks
-  * [Mix] Support `mix test --raise` that will raise when a test suite fails (instead of setting the exit code to 1)
-  * [Mix] Enable rebar3 manager by default for Hex dependencies
-  * [Mix] Add `mix escript.install` to install escripts
-  * [Mix] Print stacktraces for `Mix.Error` when `MIX_DEBUG=1` is set
-  * [Mix] Add a user friendly error for merge conflicts on `mix.lock`
-  * [Mix] Track files between path dependencies. This means umbrella applications will no longer trigger full recompilation when a sibling changes. Instead it will only recompile the files affected by the sibling changes
-  * [Mix] No longer print every file being compiled. Instead a generic "Compiling N files (.ext)" will be printed and files will only be logged in case they take more than 5 seconds to compile. This threshold can be customized by passing the `--long-compilation-threshold` flag and the previous behaviour can be reenabled by giving `--verbose` to `mix compile`
-  * [Mix] Add `mix test --stale` that uses static analysis on source files to know which tests should run when source files changes. If any test file changes, it will also re-run. Changing a configuration file or the test helper will trigger a full recompilation
+  * [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
 
-  * [Application] Ensure `Application.spec/2` returns nil for unknown applications
-  * [GenServer] Ensures `cast/2` returns `:ok` if locally registered process is not found
-  * [Inspect] Ensure binaries break into new lines when inspected
-  * [Kernel] Do not choke on capture operator with argument above `&191`
-  * [Kernel] Raise if `defstruct` is called multiple times
-  * [Kernel] Ensure `Module.create/3` respects var/alias hygiene
-  * [Kernel] Support non-literal ranges on the right side of `in/2`
-  * [Macro] Fix `Macro.to_string/1` on a call of a capture argument, for example `&(&1).(:x)`
-  * [OptionParser] Allow `OptionParser` to parse negative numbers
-  * [Record] Fix `Record.is_record/2` when dealing with non-record tuples
-  * [String] Ensure `strip` also removes non-breaking whitespaces (and ensure `split` still does not split on them)
-  * [URI] Use square brackets for IPv6 in `URI.to_string/1`
+  * [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] 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] 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 file to logger metadata
 
 #### Mix
 
-  * [Mix] Improve task not found message when Mix would include the not found task as a suggestion due to different casing
-  * [Mix] Ignore lock revision when the lock is out of date when updating Mix dependencies. Before this fix, Git tags and branches in the lock file would erroneously take higher precedence than the one in `mix.exs`
-  * [Mix] Only recompile empty Elixir files if they change instead of recompiling them on every run
-  * [Mix] Ensure .app file is written in UTF-8 (this allows app descriptions to contain UTF-8 characters)
-  * [Mix.Dep] Always specify the `:env` option internally for dependencies to avoid false positives in the dependency resolution
-  * [Mix.Dep] Correctly detect conflict from cousin optional dependencies in the dependency resolution algorithm
+  * [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
+
+#### Kernel
+
+  * [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] 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] 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)
 
-  * [Float] `Float.to_string/2` and `Float.to_char_list/2` has been soft-deprecated as Elixir will now attempt to print the shortest and most accurate representation by default. Developers can always fallback to `:erlang.float_to_binary/2` and `:erlang.float_to_list/2` if they need the previous functionality
-  * [Kernel] `to_char_list` functions have been soft-deprecated in favor of `to_charlist`. This aligns with the naming conventions in both Erlang and Elixir
-  * [String] The confusing `String.strip/2`, `String.lstrip/2` and `String.rstrip/2` API has been soft deprecated in favor of `String.trim/2`, `String.trim_leading/2` and `String.trim_trailing/2`
-  * [String] The confusing `String.ljust/3` and `String.rjust/3` API has been soft deprecated in favor of `String.pad_leading/3` and `String.pad_trailing/3`
-  * [Typespec] `char_list` is soft-deprecated in favor of `charlist`
+#### Kernel
 
-### 4. Deprecations
+  * [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`
 
-This release deprecates many APIs that have been soft-deprecated in previous Elixir versions.
+#### 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`
 
-  * [Dict] `Dict` is no longer a behaviour and its functions will be deprecated in upcoming releases
-  * [Enum] Passing a dictionary to `Enum.group_by/3` is deprecated
-  * [Kernel] `\x{H*}` in strings/sigils/charlists is deprecated
-  * [Kernel] Add deprecation for `defdelegate` list arguments and `:append_first` option. The previously undocumented and deprecated support for matching has been removed
-  * [Kernel] Warn if a variable is assigned inside `case`/`if`/etc and used outside the block
-  * [Keyword] `Keyword.size/1` is deprecated in favor of `Kernel.length/1`
-  * [Map] `Map.size/1` is deprecated in favor of `Kernel.map_size/1`
-  * [Regex] The option `/r` (for ungreedy) has been deprecated in favor of `/U`
-  * [Set] `Set` is no longer a behaviour and its functions will be deprecated in upcoming releases
-  * [String] `String.valid_character?/1` is deprecated in favor of `String.valid?/1` with pattern matching
-  * [Task] `Task.find/2` is deprecated in favor of explicit message matching
-  * [URI] Passing a non-map to `URI.decode_query/2` is deprecated

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 Stack Overflow, IRC, mailing list, etc)
-* For proposing a new feature, please start a discussion on the Elixir Core mailing list
-* For bugs, do a quick search and make sure the bug has not yet been reported
-* Finally, be nice and have fun!
-
-### Environment
-
-* Elixir version (elixir -v):
-* Operating system:
-
-### Current behavior
-
-Include code samples, errors and stacktraces if appropriate.
-
-### Expected behavior
-

Makefile

@@ -1,7 +1,6 @@
 REBAR ?= "$(CURDIR)/rebar"
 PREFIX ?= /usr/local
-DOCS := v1.3
-CANONICAL := stable
+DOCS := v1.2
 ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
 ERLC := erlc -I lib/elixir/include
 ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
@@ -12,8 +11,6 @@ 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 install_man clean_man docs Docs.zip Precompiled.zip publish_zips publish_docs publish_mix
 .NOTPARALLEL: compile
@@ -22,9 +19,9 @@ GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$hea
 
 define CHECK_ERLANG_RELEASE
 	$(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; \
+		if [ $$? != 0 ]; then                                                                                                \
+		   echo "At least Erlang 18.0 is required to build Elixir";                                                          \
+		   exit 1;                                                                                                           \
 		fi;
 endef
 
@@ -74,7 +71,7 @@ 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                  \
+	$(Q) if [ ! -f $(KERNEL) ]; then                    \
 		echo "==> bootstrap (compile)";                 \
 		$(ERL) -s elixir_compiler core -s erlang halt;  \
 	fi
@@ -88,6 +85,7 @@ $(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
 unicode: $(UNICODE)
 $(UNICODE): lib/elixir/unicode/*
 	@ echo "==> unicode (compile)";
+	@ 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))
@@ -126,18 +124,18 @@ clean:
 clean_exbeam:
 	$(Q) rm -f lib/*/ebin/Elixir.*.beam
 
-#==> Create Documentation
+#==>  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")
-COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -a http://elixir-lang.org/docs/$(CANONICAL)/$(2)/ -p http://elixir-lang.org/docs.html $(4)
+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 "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(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/Naming Conventions.md" -e "lib/elixir/pages/Typespecs.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)"

README.md

@@ -1,6 +1,6 @@
 ![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
 =========
-[![Build Status](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)
 
 For more about Elixir, installation and documentation,
@@ -8,7 +8,8 @@ For more about Elixir, installation and documentation,
 
 ## 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
@@ -29,73 +30,21 @@ If tests pass, you are ready to move on to the
 `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 the correct version and tests still fail, please
+If you have the correct version and tests still fail, feel free to
 [open an issue][2].
 
-## 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`.
-
-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 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 a new feature, please start a discussion in the
-[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
-to argue and explain why a feature is useful and how it will impact the
-codebase and the community. Finally, remember all interactions in our official
-spaces follow our [Code of Conduct][7].
-
 ## Building documentation
 
-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:
@@ -104,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](http://elixir-lang.org/docs/stable/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

@@ -24,26 +24,18 @@ This document simply outlines the release process:
 
 10. Add the release to `elixir.csv` file in `elixir-lang/elixir-lang.github.com`
 
+11. Build and push standalone Mix with `make publish_mix` (requires AWS credentials)
+
 ## New vMAJOR.MINOR releases
 
-11. Create a new branch "vMAJOR.MINOR"
+12. Create a new branch "vMAJOR.MINOR"
 
-12. Move docs generation to `docs/vMAJOR.MINOR` in Makefile, set CANONICAL to stable and copy them to `docs/stable` (change index.html accordingly)
+13. Move docs generation to `docs/vMAJOR.MINOR` in Makefile and copy them from `docs/stable` (change index.html accordingly)
 
-13. In master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vVERSION+1"
+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)
-
-## Deprecation policy
-
-Elixir deprecations happens in 3 steps:
-
-  1. The feature is soft-deprecated. It means both CHANGELOG and documentation must list the feature as deprecated but no warning is effectively emitted by running the code. There is no requirement to soft-deprecate a feature.
-
-  2. The feature is effectively deprecated by emitting warnings on usage. In order to deprecate a feature, the proposed alternative MUST exist for AT LEAST two versions. For example, `Enum.uniq/2` was soft-deprecated in favor of `Enum.uniq_by/2` in Elixir v1.1. This means a deprecation warning may only be emitted by Elixir v1.3 or later.
-
-  3. The feature is removed. This can only happen on major releases. This means deprecated features in Elixir v1.x shall only be removed by Elixir v2.x.

VERSION

@@ -1 +1 @@
-1.3.0
+1.2.2

bin/elixir

@@ -2,25 +2,22 @@
 if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
-  -v                          Prints version and exits
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -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 (*)
-  --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
-  --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
@@ -71,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,38 +1,34 @@
 @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   -v                          Prints version and exits
-echo   -e COMMAND                  Evaluates the given command (*)
-echo   -r FILE                     Requires the given files/patterns (*)
-echo   -S SCRIPT                   Finds and executes the given script in PATH
-echo   -pr FILE                    Requires the given files/patterns in parallel (*)
-echo   -pa PATH                    Prepends the given path to Erlang code path (*)
-echo   -pz PATH                    Appends the given path to Erlang code path (*)
-echo.
-echo   --app APP                   Starts the given app and its dependencies (*)
-echo   --cookie COOKIE             Sets a cookie for this distributed node
-echo   --detached                  Starts the Erlang VM detached from console
-echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo   --hidden                    Makes a hidden node
-echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
-echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
-echo   --name NAME                 Makes and assigns a name to the distributed node
-echo   --no-halt                   Does not halt the Erlang VM after execution
-echo   --sname NAME                Makes and assigns a short name to the distributed node
-echo   --werl                      Uses Erlang's Windows shell GUI
+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
@@ -70,7 +66,7 @@ if "%par%"=="""" (
 rem ******* EXECUTION OPTIONS **********************
 IF "%par%"==""--werl"" (Set useWerl=1)
 IF "%par%"==""+iex"" (Set runMode="iex")
-rem ******* ELIXIR PARAMETERS **********************
+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) 
@@ -80,14 +76,12 @@ 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 ********************

bin/elixirc

@@ -2,16 +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
-  --no-docs            Do not attach documentation to compiled modules
-  --no-debug-info      Do not attach debug info to compiled modules
-  --verbose            Print compilation status
-  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+  -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,11 +1,9 @@
 @if defined ELIXIR_CLI_ECHO (@echo on) else  (@echo off)
-setlocal
 set argc=0
 for %%A in (%*) do (
-    if /I "%%A"=="--help" goto documentation
-    if /I "%%A"=="-h"     goto documentation
-    if /I "%%A"=="/h"     goto documentation
-    if    "%%A"=="/?"     goto documentation
+    if "%%A"=="--help" goto documentation
+    if "%%A"=="-h"     goto documentation
+    if "%%A"=="/h"     goto documentation
     set /A argc+=1
 )
 if %argc%==0 goto documentation
@@ -14,20 +12,15 @@ goto run
 :documentation
 echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
 echo.
-echo  -o                   The directory to output compiled files
-echo  --no-docs            Do not attach documentation to compiled modules
-echo  --no-debug-info      Do not attach debug info to compiled modules
-echo  --verbose            Print compilation status
-echo  --warnings-as-errors Treat warnings as errors and return non-zero exit code
+echo  -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,29 +2,24 @@
 if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
   echo "Usage: `basename $0` [options] [.exs file] [data]
 
-  -v                          Prints version and exits
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -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 (*)
-  --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
-  --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

bin/iex.bat

@@ -1,45 +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  -v                          Prints version and exits
-echo  -e COMMAND                  Evaluates the given command (*)
-echo  -r FILE                     Requires the given files/patterns (*)
-echo  -S SCRIPT                   Finds and executes the given script in PATH
-echo  -pr FILE                    Requires the given files/patterns in parallel (*)
-echo  -pa PATH                    Prepends the given path to Erlang code path (*)
-echo  -pz PATH                    Appends the given path to Erlang code path (*)
-echo.
-echo  --app APP                   Starts the given app and its dependencies (*)
-echo  --cookie COOKIE             Sets a cookie for this distributed node
-echo  --detached                  Starts the Erlang VM detached from console
-echo  --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo  --hidden                    Makes a hidden node
-echo  --logger-otp-reports BOOL   Enables or disables OTP reporting
-echo  --logger-sasl-reports BOOL  Enables or disables SASL reporting
-echo  --name NAME                 Makes and assigns a name to the distributed node
-echo  --no-halt                   Does not halt the Erlang VM after execution
-echo  --sname NAME                Makes and assigns a short name to the distributed node
-echo  --werl                      Uses Erlang's Windows shell GUI (Windows only)
-echo.
-echo  --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
-echo                              path can be empty, then no file will be loaded
-echo  --remsh NAME                Connects to a node using a remote shell
-echo.
-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" +iex --erl "-user Elixir.IEx.CLI" --no-halt %__ELIXIR_IEX_FLAGS% %*
-:end
-ENDLOCAL
+@set __ELIXIR_IEX_FLAGS=

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.
   """
 

lib/eex/lib/eex/compiler.ex

@@ -17,7 +17,7 @@ defmodule EEx.Compiler do
       {:ok, tokens} ->
         state = %{engine: opts[:engine] || @default_engine,
                   file: file, line: line, quoted: [], start_line: nil}
-        generate_buffer(tokens, state.engine.init(opts), [], state)
+        generate_buffer(tokens, "", [], state)
       {:error, line, message} ->
         raise EEx.SyntaxError, line: line, file: file, message: message
     end
@@ -25,38 +25,38 @@ defmodule EEx.Compiler do
 
   # Generates the buffers by handling each expression from the tokenizer
 
-  defp generate_buffer([{:text, chars} | t], 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(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:expr, line, mark, chars} | t], 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(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:start_expr, start_line, mark, chars} | t], buffer, scope, state) do
+  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],
+    {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(t, buffer, scope, state)
   end
 
-  defp generate_buffer([{:middle_expr, line, _, chars} | t], 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(t, "", [wrapped | scope], %{state | line: line})
+    generate_buffer(t, "", [wrapped|scope], %{state | line: line})
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars} | t], 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, t}
   end
 
-  defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
+  defp generate_buffer([{:end_expr, line, _, chars}|_], _buffer, [], state) do
     raise EEx.SyntaxError, message: "unexpected token #{inspect chars}", file: state.file, line: line
   end
 
@@ -74,14 +74,14 @@ 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, 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} | t]=list, 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, t}
     else

lib/eex/lib/eex/engine.ex

@@ -4,8 +4,6 @@ defmodule EEx.Engine do
 
   An engine needs to implement three functions:
 
-    * `init(opts)` - returns the initial buffer
-
     * `handle_body(quoted)` - receives the final built quoted
       expression, should do final post-processing and return a
       quoted expression.
@@ -27,7 +25,6 @@ defmodule EEx.Engine do
   default implementations for the functions above.
   """
 
-  @callback init(Keyword.t) :: Macro.t
   @callback handle_body(Macro.t) :: Macro.t
   @callback handle_text(Macro.t, String.t) :: Macro.t
   @callback handle_expr(Macro.t, String.t, Macro.t) :: Macro.t
@@ -37,10 +34,6 @@ defmodule EEx.Engine do
     quote do
       @behaviour EEx.Engine
 
-      def init(opts) do
-        EEx.Engine.init(opts)
-      end
-
       def handle_body(body) do
         EEx.Engine.handle_body(body)
       end
@@ -53,7 +46,7 @@ defmodule EEx.Engine do
         EEx.Engine.handle_expr(buffer, marker, expr)
       end
 
-      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2, init: 1]
+      defoverridable [handle_body: 1, handle_expr: 3, handle_text: 2]
     end
   end
 
@@ -81,27 +74,21 @@ defmodule EEx.Engine do
   end
 
   @doc false
-  # TODO: Raise on 2.0
+  # 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 """
   The default implementation simply returns the given expression.
   """

lib/eex/lib/eex/tokenizer.ex

@@ -2,7 +2,7 @@ defmodule EEx.Tokenizer do
   @moduledoc false
 
   @doc """
-  Tokenizes the given charlist or binary.
+  Tokenizes the given char list or binary.
 
   It returns {:ok, list} with the following tokens:
 
@@ -17,7 +17,7 @@ defmodule EEx.Tokenizer do
   def tokenize(bin, line, opts \\ [])
 
   def tokenize(bin, line, opts) when is_binary(bin) do
-    tokenize(String.to_charlist(bin), line, opts)
+    tokenize(String.to_char_list(bin), line, opts)
   end
 
   def tokenize(list, line, opts) do
@@ -25,7 +25,7 @@ defmodule EEx.Tokenizer do
   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
@@ -52,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
@@ -75,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
@@ -98,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
 
@@ -143,7 +143,7 @@ defmodule EEx.Tokenizer do
     Enum.find_index tokens, fn
       {:fn_paren, _} -> true
       {:fn, _}       -> true
-      _              -> false
+      _                -> false
     end
   end
 
@@ -190,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
@@ -198,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/test/eex/smart_engine_test.exs

@@ -3,8 +3,6 @@ Code.require_file "../test_helper.exs", __DIR__
 defmodule EEx.SmartEngineTest do
   use ExUnit.Case, async: true
 
-  import ExUnit.CaptureIO
-
   test "evaluates simple string" do
     assert_eval "foo bar", "foo bar"
   end
@@ -17,13 +15,6 @@ defmodule EEx.SmartEngineTest do
     assert_eval "1", "<%= @foo %>", assigns: %{foo: 1}
   end
 
-  test "error with missing assigns" do
-    stderr = capture_io(:stderr, fn ->
-      assert_eval "", "<%= @foo %>", assigns: %{}
-    end)
-    assert stderr =~ "assign @foo not available in EEx template"
-  end
-
   test "evaluates with loops" do
     assert_eval "1\n2\n3\n", "<%= for x <- [1, 2, 3] do %><%= x %>\n<% end %>"
   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

@@ -99,7 +99,7 @@ defmodule EExTest do
   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) ) %>"
+    assert_eval " 101  102  103 ", "<%= Enum.map([1,2,3], (fn x -> %> <%= 100 + x %> <% end) ) %>"
   end
 
   test "evaluates with defined variable" do
@@ -316,7 +316,7 @@ foo
     assert_eval "\ndone\n", string, packages: nil, all: nil
   end
 
-  test "Unicode" do
+  test "unicode" do
     template = """
       • <%= "•" %> •
       <%= "Jößé Vâlìm" %> Jößé Vâlìm
@@ -344,7 +344,7 @@ foo
   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 ->
+    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
@@ -370,7 +370,7 @@ foo
         {EExTest.Compiled,
           :before_compile,
           0,
-          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 7]
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 7]
        }
      }
 
@@ -379,7 +379,7 @@ foo
         {EExTest.Compiled,
           :after_compile,
           0,
-          [file: to_charlist(Path.relative_to_cwd(__ENV__.file)), line: 22]
+          [file: to_char_list(Path.relative_to_cwd(__ENV__.file)), line: 22]
        }
      }
 
@@ -396,10 +396,6 @@ foo
   defmodule TestEngine do
     @behaviour EEx.Engine
 
-    def init(_opts) do
-      ""
-    end
-
     def handle_body(body) do
       {:wrapped, body}
     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,14 +8,7 @@ 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.
-
-  ## Dynamic lookups
+  ## Key-based lookups
 
   Out of the box, Access works with `Keyword` and `Map`:
 
@@ -51,21 +44,19 @@ defmodule Access do
       nil
 
   Since Access is a behaviour, it can be implemented to key-value
-  data structures. The implementation should be added to the
-  module that defines the struct being access. Access requires the
-  key comparison to be implemented using the `===` operator.
+  data structures. Access requires the key comparison to be
+  implemented using the `===` operator.
 
-  ## Static lookups
+  ## Field-based lookups
 
   The Access syntax (`foo[bar]`) cannot be used to access fields in
-  structs, since structs do not implement the Access behaviour by
-  default. It is also design decision: the dynamic access lookup
-  is meant to be used for dynamic key-value structures, like maps
-  and keywords, and not by static ones like structs.
+  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 map and structs
-  fields. Imagine a struct named `User` with name and age fields.
-  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[:name]
@@ -83,8 +74,9 @@ defmodule Access do
       put_in user.name, "mary"
       %User{name: "mary"}
 
-  Differently from `user[:name]`, `user.name` is not extensible via
-  a behaviour and is restricted to only maps and structs.
+  Differently from `user[:name]`, `user.name` cannot be extended by
+  the developers, and will be always restricted to only maps and
+  structs.
 
   Summing up:
 
@@ -93,26 +85,6 @@ 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 with a list of languages, here is how to
-  deeply traverse the map and convert all language names to uppercase:
-
-      iex> user = %{name: "john",
-      ...>          languages: [%{name: "elixir", type: :functional},
-      ...>                      %{name: "c", type: :procedural}]}
-      iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
-      %{name: "john",
-        languages: [%{name: "ELIXIR", type: :functional},
-                    %{name: "C", type: :procedural}]}
-
-  See the functions `key/1`, `key!/1`, `elem/1` and `all/0` for the current
-  accessors.
   """
 
   @type t :: list | map | nil
@@ -120,16 +92,14 @@ defmodule Access do
   @type value :: any
 
   @callback fetch(t, key) :: {:ok, value} | :error
-  @callback get(t, key, value) :: value
-  @callback get_and_update(t, key, (value -> {value, value} | :pop)) :: {value, t}
-  @callback pop(t, key) :: {value, t}
+  @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)
@@ -185,17 +155,15 @@ defmodule Access do
   @doc """
   Gets and updates the container's value for the given key, in a single 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 map 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 tuple with the "get" value returned by
-  `fun` and a new map 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(t, key, (value -> {get, value})) :: {get, t} when get: var
+  @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
@@ -206,7 +174,13 @@ defmodule Access do
   end
 
   def get_and_update(%{} = map, key, fun) do
-    Map.get_and_update(map, key, fun)
+    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
@@ -217,275 +191,4 @@ defmodule Access do
     raise ArgumentError,
       "could not put/update key #{inspect key} on a nil value"
   end
-
-  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(list, key) when is_list(list), do: Keyword.pop(list, key)
-  def pop(map, key) when is_map(map) do
-    case map do
-      %{^key => value} -> {value, :maps.remove(key, map)}
-      %{} -> {nil, map}
-    end
-  end
-  def pop(nil, key) do
-    raise ArgumentError,
-      "could not pop key #{inspect key} on a nil value"
-  end
-
-  ## Accessors
-
-  @doc """
-  Accesses the given key in a map/struct.
-
-  Uses the default value if the key does not exist
-  or if the value being accessed is `nil`.
-
-  ## Examples
-
-      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name)])
-      nil
-      iex> get_in(%{}, [Access.key(:unknown, %{name: "john"}), Access.key(:name)])
-      "john"
-      iex> get_in(%{}, [Access.key(:unknown), Access.key(:name, "john")])
-      "john"
-
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key(:unknown), Access.key(:name, "john")])
-      "john"
-      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key(:user), Access.key(:name)])
-      {"john", %{user: %{}}}
-
-  An error is raised if the accessed structure is not a map/struct/nil:
-
-      iex> get_in([], [Access.key(:foo)])
-      ** (RuntimeError) Access.key/1 expected a map/struct or nil, got: []
-
-  """
-  def key(key, default \\ nil) do
-    fn
-      :get, data, next ->
-        next.(Map.get(to_map(data), key, default))
-      :get_and_update, data, next ->
-        value = Map.get(to_map(data), key, default)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-    end
-  end
-
-  defp to_map(nil), do: %{}
-  defp to_map(%{} = map), do: map
-  defp to_map(data), do: raise "Access.key/1 expected a map/struct or nil, got: #{inspect data}"
-
-  @doc """
-  Accesses the given key in a map/struct.
-
-  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: []
-
-  """
-  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"""
-  Accesses the element at the given index in a tuple.
-
-  Raises if the index is out of bounds.
-
-  ## Examples
-
-      iex> map = %{user: {"john", 27}}
-      iex> get_in(map, [:user, Access.elem(0)])
-      "john"
-      iex> get_and_update_in(map, [:user, Access.elem(0)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> 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: %{}
-
-  """
-  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"""
-  Accesses all the elements in a list.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.all(), :name])
-      ["john", "mary"]
-      iex> get_and_update_in(list, [Access.all(), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> 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 multipling odd numbers by 2:
-
-      iex> require Integer
-      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn
-      ...>   num -> if Integer.is_even(num), do: :pop, else: {num, num * 2}
-      ...> 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: %{}
-
-  """
-  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, [], [])
-  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"""
-  Accesses the element at `index` (zero based) of a list.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.at(1), :name])
-      "mary"
-      iex> get_and_update_in(list, [Access.at(0), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", [%{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: %{}
-  """
-  def at(index) when index >= 0 do
-    fn(op, data, next) -> at(op, data, index, next) end
-  end
-
-  defp at(:get, data, index, next) when is_list(data) do
-    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([head | 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

@@ -307,6 +307,13 @@ defmodule Agent do
   """
   @spec stop(agent, reason :: term, timeout) :: :ok
   def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    :gen.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

@@ -90,65 +90,10 @@ defmodule Application do
   supervisor is automatically handled by the VM.
   """
 
-  @doc """
-  Called when an application is started.
-
-  This function is called when an the application is started using
-  `Application.start/2` (and functions on top of that, such as
-  `Application.ensure_started/2`). This function should start the top-level
-  process of the application (which should be the top supervisor of the
-  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 mode and the application specification key `:start_phases`
-      is `:undefined`.
-    * `{:takeover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on the node `node`.
-    * `{: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 `stop/2` callback for more information).
-
-  `use Application` provides no default implementation for the `start/2`
-  callback.
-  """
-  @callback start(start_type, start_args :: term) ::
-    {:ok, pid} |
-    {:ok, pid, state} |
-    {:error, reason :: term}
-
-  @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 false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour Application
+      @behaviour :application
 
       @doc false
       def stop(_state) do
@@ -162,7 +107,6 @@ defmodule Application do
   @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,
@@ -189,20 +133,18 @@ defmodule Application do
   @doc """
   Returns the value for `key` in `app`'s specification.
 
-  See `spec/1` for the supported keys. If the given
+  See `spec/1` for the supporte keys. If the given
   specification parameter does not exist, this function
-  will raise. Returns `nil` if the application is not loaded.
+  will raise.
   """
-  @spec spec(app, key) :: value | nil
+  @spec spec(app, key) :: value
   def spec(app, key) when key in @application_keys do
-    case :application.get_key(app, key) do
-      {:ok, value} -> value
-      :undefined -> nil
-    end
+    {:ok, value} = :application.get_key(app, key)
+    value
   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
@@ -432,13 +374,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.
@@ -464,7 +403,7 @@ 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 builtin one
       # causing an error.
@@ -474,68 +413,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,23 +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: Deprecate by v1.5
-  @doc false
-  @spec to_char_list(atom) :: charlist
-  def to_char_list(atom), do: Atom.to_charlist(atom)
 end

lib/elixir/lib/base.ex

@@ -138,28 +138,11 @@ defmodule Base do
   defp from_mixed(char),
     do: char
 
-  defp maybe_pad(subject, false, _, _),
-    do: subject
-  defp maybe_pad(subject, _, group_size, pad) do
-    case rem(byte_size(subject), group_size) do
-      0 -> subject
-      x -> subject <> String.duplicate(pad, group_size - x)
-    end
-  end
-
   @doc """
   Encodes a binary string into a base 16 encoded string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -180,17 +163,9 @@ defmodule Base do
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -215,17 +190,9 @@ defmodule Base do
   @doc """
   Decodes a base 16 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -258,56 +225,29 @@ defmodule Base do
   @doc """
   Encodes a binary string into a base 64 encoded string.
 
-  Accepts `padding: false` option which will omit padding from
-  the output string.
-
   ## Examples
 
       iex> Base.encode64("foobar")
       "Zm9vYmFy"
 
-      iex> Base.encode64("foob")
-      "Zm9vYg=="
-
-      iex> Base.encode64("foob", padding: false)
-      "Zm9vYg"
-
   """
   @spec encode64(binary) :: binary
-  @spec encode64(binary, Keyword.t) :: binary
-  def encode64(data, opts \\ []) when is_binary(data) do
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode64(data, pad?)
+  def encode64(data) when is_binary(data) do
+    do_encode64(data)
   end
 
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   ## Examples
 
       iex> Base.decode64("Zm9vYmFy")
       {:ok, "foobar"}
 
-      iex> Base.decode64("Zm9vYmFy\\n", ignore: :whitespace)
-      {:ok, "foobar"}
-
-      iex> Base.decode64("Zm9vYg==")
-      {:ok, "foob"}
-
-      iex> Base.decode64("Zm9vYg", padding: false)
-      {:ok, "foob"}
-
   """
   @spec decode64(binary) :: {:ok, binary} | :error
-  @spec decode64(binary, Keyword.t) :: {:ok, binary} | :error
-  def decode64(string, opts \\ []) when is_binary(string) do
-    {:ok, decode64!(string, opts)}
+  def decode64(string) when is_binary(string) do
+    {:ok, decode64!(string)}
   rescue
     ArgumentError -> :error
   end
@@ -315,11 +255,7 @@ defmodule Base do
   @doc """
   Decodes a base 64 encoded string into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
+  The following alphabet is used both for encoding and decoding:
 
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
@@ -329,72 +265,44 @@ defmodule Base do
       iex> Base.decode64!("Zm9vYmFy")
       "foobar"
 
-      iex> Base.decode64!("Zm9vYmFy\\n", ignore: :whitespace)
-      "foobar"
-
-      iex> Base.decode64!("Zm9vYg==")
-      "foob"
-
-      iex> Base.decode64!("Zm9vYg", padding: false)
-      "foob"
-
   """
   @spec decode64!(binary) :: binary
-  @spec decode64!(binary, Keyword.t) :: binary
-  def decode64!(string, opts \\ []) when is_binary(string) do
-    pad? = Keyword.get(opts, :padding, true)
-    string |> remove_ignored(opts[:ignore]) |> do_decode64(pad?)
+  def decode64!(string) when is_binary(string) and rem(byte_size(string), 4) == 0 do
+    do_decode64(string)
+  end
+
+  def decode64!(string) when is_binary(string) do
+    raise ArgumentError, "incorrect padding"
   end
 
   @doc """
   Encodes a binary string into a base 64 encoded string with URL and filename
   safe alphabet.
 
-  Accepts `padding: false` option which will omit padding from
-  the output string.
-
   ## Examples
 
       iex> Base.url_encode64(<<255, 127, 254, 252>>)
       "_3_-_A=="
 
-      iex> Base.url_encode64(<<255, 127, 254, 252>>, padding: false)
-      "_3_-_A"
-
   """
   @spec url_encode64(binary) :: binary
-  @spec url_encode64(binary, Keyword.t) :: binary
-  def url_encode64(data, opts \\ []) when is_binary(data) do
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode64url(data, pad?)
+  def url_encode64(data) when is_binary(data) do
+    do_encode64url(data)
   end
 
   @doc """
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   ## Examples
 
       iex> Base.url_decode64("_3_-_A==")
       {:ok, <<255, 127, 254, 252>>}
 
-      iex> Base.url_decode64("_3_-_A==\\n", ignore: :whitespace)
-      {:ok, <<255, 127, 254, 252>>}
-
-      iex> Base.url_decode64("_3_-_A", padding: false)
-      {:ok, <<255, 127, 254, 252>>}
-
   """
   @spec url_decode64(binary) :: {:ok, binary} | :error
-  @spec url_decode64(binary, Keyword.t) :: {:ok, binary} | :error
-  def url_decode64(string, opts \\ []) when is_binary(string) do
-    {:ok, url_decode64!(string, opts)}
+  def url_decode64(string) when is_binary(string) do
+    {:ok, url_decode64!(string)}
   rescue
     ArgumentError -> :error
   end
@@ -403,12 +311,6 @@ defmodule Base do
   Decodes a base 64 encoded string with URL and filename safe alphabet
   into a binary string.
 
-  Accepts `ignore: :whitespace` option which will ignore all the
-  whitespace characters in the input string.
-
-  Accepts `padding: false` option which will ignore padding from
-  the input string.
-
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
@@ -417,39 +319,21 @@ defmodule Base do
       iex> Base.url_decode64!("_3_-_A==")
       <<255, 127, 254, 252>>
 
-      iex> Base.url_decode64!("_3_-_A==\\n", ignore: :whitespace)
-      <<255, 127, 254, 252>>
-
-      iex> Base.url_decode64!("_3_-_A", padding: false)
-      <<255, 127, 254, 252>>
-
   """
   @spec url_decode64!(binary) :: binary
-  @spec url_decode64!(binary, Keyword.t) :: binary
-  def url_decode64!(string, opts \\ []) when is_binary(string)  do
-    pad? = Keyword.get(opts, :padding, true)
-    string |> remove_ignored(opts[:ignore]) |> do_decode64url(pad?)
+  def url_decode64!(string) when is_binary(string) and rem(byte_size(string), 4) == 0 do
+    do_decode64url(string)
+  end
+
+  def url_decode64!(string) when is_binary(string) do
+    raise ArgumentError, "incorrect padding"
   end
 
   @doc """
   Encodes a binary string into a base 32 encoded string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-    * `:padding` - specifies whether to apply padding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
-
-  The values for `:padding` can be:
-
-    * `true` - pad the output string to the nearest multiple of 8 (default)
-    * `false` - omit padding from the output string
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -459,38 +343,20 @@ defmodule Base do
       iex> Base.encode32("foobar", case: :lower)
       "mzxw6ytboi======"
 
-      iex> Base.encode32("foobar", padding: false)
-      "MZXW6YTBOI"
-
   """
   @spec encode32(binary) :: binary
   @spec encode32(binary, Keyword.t) :: binary
   def encode32(data, opts \\ []) when is_binary(data) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_encode32(case, data, pad?)
+    do_encode32(case, data)
   end
 
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow  upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -503,9 +369,6 @@ defmodule Base do
       iex> Base.decode32("mzXW6ytBOi======", case: :mixed)
       {:ok, "foobar"}
 
-      iex> Base.decode32("MZXW6YTBOI", padding: false)
-      {:ok, "foobar"}
-
   """
   @spec decode32(binary) :: {:ok, binary} | :error
   @spec decode32(binary, Keyword.t) :: {:ok, binary} | :error
@@ -518,27 +381,13 @@ defmodule Base do
   @doc """
   Decodes a base 32 encoded string into a binary string.
 
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
+
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
-
   ## Examples
 
       iex> Base.decode32!("MZXW6YTBOI======")
@@ -550,38 +399,26 @@ defmodule Base do
       iex> Base.decode32!("mzXW6ytBOi======", case: :mixed)
       "foobar"
 
-      iex> Base.decode32!("MZXW6YTBOI", padding: false)
-      "foobar"
-
   """
   @spec decode32!(binary) :: binary
   @spec decode32!(binary, Keyword.t) :: binary
-  def decode32!(string, opts \\ []) when is_binary(string) do
+  def decode32!(string, opts \\ [])
+
+  def decode32!(string, opts) when is_binary(string) and rem(byte_size(string), 8) == 0 do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_decode32(case, string, pad?)
+    do_decode32(case, string)
+  end
+
+  def decode32!(string, _opts) when is_binary(string) do
+    raise ArgumentError, "incorrect padding"
   end
 
   @doc """
   Encodes a binary string into a base 32 encoded string with an
   extended hexadecimal alphabet.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to use when encoding
-    * `:padding` - specifies whether to apply padding
-
-  The values for `:case` can be:
-
-    * `:upper` - use upper case characters (default)
-    * `:lower` - use lower case characters
-
-  The values for `:padding` can be:
-
-    * `true` - pad the output string to the nearest multiple of 8 (default)
-    * `false` - omit padding from the output string
+  Accepts an atom `:upper` (default) for encoding to upper case characters or
+  `:lower` for lower case characters.
 
   ## Examples
 
@@ -591,39 +428,21 @@ defmodule Base do
       iex> Base.hex_encode32("foobar", case: :lower)
       "cpnmuoj1e8======"
 
-      iex> Base.hex_encode32("foobar", padding: false)
-      "CPNMUOJ1E8"
-
   """
   @spec hex_encode32(binary) :: binary
   @spec hex_encode32(binary, Keyword.t) :: binary
   def hex_encode32(data, opts \\ []) when is_binary(data) do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_hex_encode32(case, data, pad?)
+    do_hex_encode32(case, data)
   end
 
   @doc """
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
 
   ## Examples
 
@@ -636,9 +455,6 @@ defmodule Base do
       iex> Base.hex_decode32("cpnMuOJ1E8======", case: :mixed)
       {:ok, "foobar"}
 
-      iex> Base.hex_decode32("CPNMUOJ1E8", padding: false)
-      {:ok, "foobar"}
-
   """
   @spec hex_decode32(binary) :: {:ok, binary} | :error
   @spec hex_decode32(binary, Keyword.t) :: {:ok, binary} | :error
@@ -652,27 +468,13 @@ defmodule Base do
   Decodes a base 32 encoded string with extended hexadecimal alphabet
   into a binary string.
 
+  Accepts an atom `:upper` (default) for decoding from upper case characters or
+  `:lower` for lower case characters. `:mixed` can be given for mixed case
+  characters.
+
   An `ArgumentError` exception is raised if the padding is incorrect or
   a non-alphabet character is present in the string.
 
-  ## Options
-
-  The accepted options are:
-
-    * `:case` - specifies the character case to accept when decoding
-    * `:padding` - specifies whether to require padding
-
-  The values for `:case` can be:
-
-    * `:upper` - only allow upper case characters (default)
-    * `:lower` - only allow lower case characters
-    * `:mixed` - allow mixed case characters
-
-  The values for `:padding` can be:
-
-    * `true` - require the input string to be padded to the nearest multiple of 8 (default)
-    * `false` - ignore padding from the input string
-
   ## Examples
 
       iex> Base.hex_decode32!("CPNMUOJ1E8======")
@@ -684,21 +486,18 @@ defmodule Base do
       iex> Base.hex_decode32!("cpnMuOJ1E8======", case: :mixed)
       "foobar"
 
-      iex> Base.hex_decode32!("CPNMUOJ1E8", padding: false)
-      "foobar"
-
   """
   @spec hex_decode32!(binary) :: binary
   @spec hex_decode32!(binary, Keyword.t) :: binary
-  def hex_decode32!(string, opts \\ []) when is_binary(string) do
+  def hex_decode32!(string, opts \\ [])
+
+  def hex_decode32!(string, opts) when is_binary(string) and rem(byte_size(string), 8) == 0 do
     case = Keyword.get(opts, :case, :upper)
-    pad? = Keyword.get(opts, :padding, true)
-    do_hex_decode32(case, string, pad?)
+    do_hex_decode32(case, string)
   end
 
-  defp remove_ignored(string, nil), do: string
-  defp remove_ignored(string, :whitespace) do
-    for <<c::8 <- string>>, not c in '\s\t\r\n', into: <<>>, do: <<c::8>>
+  def hex_decode32!(string, _opts) when is_binary(string) do
+    raise ArgumentError, "incorrect padding"
   end
 
   defp do_encode16(_, <<>>), do: <<>>
@@ -726,219 +525,213 @@ defmodule Base do
     end
   end
 
-  defp do_encode64(<<>>, _), do: <<>>
-  defp do_encode64(data, pad?) do
+  defp do_encode64(<<>>), do: <<>>
+  defp do_encode64(data) do
     split =  3 * div(byte_size(data), 3)
     <<main::size(split)-binary, rest::binary>> = data
     main = for <<c::6 <- main>>, into: <<>>, do: <<enc64(c)::8>>
-    tail = case rest do
+    case rest do
       <<c1::6, c2::6, c3::4>> ->
-        <<enc64(c1)::8, enc64(c2)::8, enc64(bsl(c3, 2))::8>>
+        <<main::binary, enc64(c1)::8, enc64(c2)::8, enc64(bsl(c3, 2))::8, ?=>>
       <<c1::6, c2::2>> ->
-        <<enc64(c1)::8, enc64(bsl(c2, 4))::8>>
+        <<main::binary, enc64(c1)::8, enc64(bsl(c2, 4))::8, ?=, ?=>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> maybe_pad(tail, pad?, 4, "=")
   end
 
-  defp do_decode64(<<>>, _), do: <<>>
-  defp do_decode64(string, false) do
-    maybe_pad(string, true, 4, "=") |> do_decode64(true)
-  end
-  defp do_decode64(string, _pad?) when rem(byte_size(string), 4) == 0 do
+  defp do_decode64(<<>>), do: <<>>
+  defp do_decode64(string) do
     split = byte_size(string) - 4
     <<main::size(split)-binary, rest::binary>> = string
     main = for <<c::8 <- main>>, into: <<>>, do: <<dec64(c)::6>>
-    tail = case rest do
+    case rest do
       <<c1::8, c2::8, ?=, ?=>> ->
-        <<dec64(c1)::6, bsr(dec64(c2), 4)::2>>
+        <<main::binary, dec64(c1)::6, bsr(dec64(c2), 4)::2>>
       <<c1::8, c2::8, c3::8, ?=>> ->
-        <<dec64(c1)::6, dec64(c2)::6, bsr(dec64(c3), 2)::4>>
+        <<main::binary, dec64(c1)::6, dec64(c2)::6, bsr(dec64(c3), 2)::4>>
       <<c1::8, c2::8, c3::8, c4::8>> ->
-        <<dec64(c1)::6, dec64(c2)::6, dec64(c3)::6, dec64(c4)::6>>
+        <<main::binary, dec64(c1)::6, dec64(c2)::6, dec64(c3)::6, dec64(c4)::6>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> tail
-  end
-  defp do_decode64(_, _) do
-    raise ArgumentError, "incorrect padding"
   end
 
-  defp do_encode64url(<<>>, _), do: <<>>
-  defp do_encode64url(data, pad?) do
+  defp do_encode64url(<<>>), do: <<>>
+  defp do_encode64url(data) do
     split =  3 * div(byte_size(data), 3)
     <<main::size(split)-binary, rest::binary>> = data
     main = for <<c::6 <- main>>, into: <<>>, do: <<enc64url(c)::8>>
-    tail = case rest do
+    case rest do
       <<c1::6, c2::6, c3::4>> ->
-        <<enc64url(c1)::8, enc64url(c2)::8, enc64url(bsl(c3, 2))::8>>
+        <<main::binary, enc64url(c1)::8, enc64url(c2)::8, enc64url(bsl(c3, 2))::8, ?=>>
       <<c1::6, c2::2>> ->
-        <<enc64url(c1)::8, enc64url(bsl(c2, 4))::8>>
+        <<main::binary, enc64url(c1)::8, enc64url(bsl(c2, 4))::8, ?=, ?=>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> maybe_pad(tail, pad?, 4, "=")
   end
 
-  defp do_decode64url(<<>>, _), do: <<>>
-  defp do_decode64url(string, false) do
-    maybe_pad(string, true, 4, "=") |> do_decode64url(true)
-  end
-  defp do_decode64url(string, _pad?) when rem(byte_size(string), 4) == 0 do
+  defp do_decode64url(<<>>), do: <<>>
+  defp do_decode64url(string) do
     split = byte_size(string) - 4
     <<main::size(split)-binary, rest::binary>> = string
     main = for <<c::8 <- main>>, into: <<>>, do: <<dec64url(c)::6>>
-    tail = case rest do
+    case rest do
       <<c1::8, c2::8, ?=, ?=>> ->
-        <<dec64url(c1)::6, bsr(dec64url(c2), 4)::2>>
+        <<main::binary, dec64url(c1)::6, bsr(dec64url(c2), 4)::2>>
       <<c1::8, c2::8, c3::8, ?=>> ->
-        <<dec64url(c1)::6, dec64url(c2)::6, bsr(dec64url(c3), 2)::4>>
+        <<main::binary, dec64url(c1)::6, dec64url(c2)::6, bsr(dec64url(c3), 2)::4>>
       <<c1::8, c2::8, c3::8, c4::8>> ->
-        <<dec64url(c1)::6, dec64url(c2)::6, dec64url(c3)::6, dec64url(c4)::6>>
+        <<main::binary, dec64url(c1)::6, dec64url(c2)::6, dec64url(c3)::6, dec64url(c4)::6>>
       <<>> ->
-        <<>>
+        main
     end
-    main <> tail
-  end
-  defp do_decode64url(_, _) do
-    raise ArgumentError, "incorrect padding"
   end
 
-  defp do_encode32(_, <<>>, _), do: <<>>
+
+
+  defp do_encode32(_, <<>>), do: <<>>
 
   for {case, fun} <- [upper: :to_upper, lower: :to_lower] do
-    defp do_encode32(unquote(case), data, pad?) do
+    defp do_encode32(unquote(case), data) do
       split =  5 * div(byte_size(data), 5)
       <<main::size(split)-binary, rest::binary>> = data
       main = for <<c::5 <- main>>, into: <<>>, do: <<unquote(fun)(enc32(c))::8>>
-      tail = case rest do
+      case rest do
         <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
+          <<main::binary,
+            unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
             unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(c4))::8,
             unquote(fun)(enc32(c5))::8, unquote(fun)(enc32(c6))::8,
-            unquote(fun)(enc32(bsl(c7, 3)))::8>>
+            unquote(fun)(enc32(bsl(c7, 3)))::8, ?=>>
         <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
+          <<main::binary,
+            unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
             unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(c4))::8,
-            unquote(fun)(enc32(bsl(c5, 1)))::8>>
+            unquote(fun)(enc32(bsl(c5, 1)))::8, ?=,  ?=, ?=>>
         <<c1::5, c2::5, c3::5, c4::1>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
-            unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(bsl(c4, 4)))::8>>
+          <<main::binary,
+            unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(c2))::8,
+            unquote(fun)(enc32(c3))::8, unquote(fun)(enc32(bsl(c4, 4)))::8,
+            ?=, ?=,  ?=, ?=>>
         <<c1::5, c2::3>> ->
-          <<unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(bsl(c2, 2)))::8>>
+          <<main::binary,
+            unquote(fun)(enc32(c1))::8, unquote(fun)(enc32(bsl(c2, 2)))::8, ?=, ?=,
+            ?=, ?=, ?=, ?=>>
         <<>> ->
-          <<>>
+          main
       end
-      main <> maybe_pad(tail, pad?, 8, "=")
     end
   end
 
-  defp do_decode32(_, <<>>, _), do: <<>>
-  defp do_decode32(case, string, false),
-    do: do_decode32(case, maybe_pad(string, true, 8, "="), true)
+  defp do_decode32(_, <<>>), do: <<>>
 
   for {case, fun} <- [upper: :from_upper, lower: :from_lower, mixed: :from_mixed] do
-    defp do_decode32(unquote(case), string, _pad?) when rem(byte_size(string), 8) == 0 do
+    defp do_decode32(unquote(case), string) do
       split = byte_size(string) - 8
       <<main::size(split)-binary, rest::binary>> = string
       main = for <<c::8 <- main>>, into: <<>>, do: <<dec32(unquote(fun)(c))::5>>
-      tail = case rest do
+      case rest do
         <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, bsr(dec32(unquote(fun)(c2)), 2)::3>>
+          <<main::binary, dec32(unquote(fun)(c1))::5,
+            bsr(dec32(unquote(fun)(c2)), 2)::3>>
         <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
             dec32(unquote(fun)(c3))::5, bsr(dec32(unquote(fun)(c4)), 4)::1>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
             dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
             bsr(dec32(unquote(fun)(c5)), 1)::4>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
             dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
             dec32(unquote(fun)(c5))::5, dec32(unquote(fun)(c6))::5,
             bsr(dec32(unquote(fun)(c7)), 3)::2>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
-          <<dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32(unquote(fun)(c1))::5, dec32(unquote(fun)(c2))::5,
             dec32(unquote(fun)(c3))::5, dec32(unquote(fun)(c4))::5,
             dec32(unquote(fun)(c5))::5, dec32(unquote(fun)(c6))::5,
             dec32(unquote(fun)(c7))::5, dec32(unquote(fun)(c8))::5>>
         <<>> ->
-          <<>>
+          main
       end
-      main <> tail
     end
   end
 
-  defp do_decode32(_, _, _),
-    do: raise ArgumentError, "incorrect padding"
-
-  defp do_hex_encode32(_, <<>>, _), do: <<>>
+  defp do_hex_encode32(_, <<>>), do: <<>>
 
   for {case, fun} <- [upper: :to_upper, lower: :to_lower] do
-    defp do_hex_encode32(unquote(case), data, pad?) do
+    defp do_hex_encode32(unquote(case), data) do
       split =  5 * div(byte_size(data), 5)
       <<main::size(split)-binary, rest::binary>> = data
       main = for <<c::5 <- main>>, into: <<>>, do: <<unquote(fun)(enc32hex(c))::8>>
-      tail = case rest do
+      case rest do
         <<c1::5, c2::5, c3::5, c4::5, c5::5, c6::5, c7::2>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
+          <<main::binary,
+            unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
             unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(c4))::8,
             unquote(fun)(enc32hex(c5))::8, unquote(fun)(enc32hex(c6))::8,
-            unquote(fun)(enc32hex(bsl(c7, 3)))::8>>
+            unquote(fun)(enc32hex(bsl(c7, 3)))::8, ?=>>
         <<c1::5, c2::5, c3::5, c4::5, c5::4>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
+          <<main::binary,
+            unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
             unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(c4))::8,
-            unquote(fun)(enc32hex(bsl(c5, 1)))::8>>
+            unquote(fun)(enc32hex(bsl(c5, 1)))::8, ?=,  ?=, ?=>>
         <<c1::5, c2::5, c3::5, c4::1>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
-            unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(bsl(c4, 4)))::8>>
+          <<main::binary,
+            unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(c2))::8,
+            unquote(fun)(enc32hex(c3))::8, unquote(fun)(enc32hex(bsl(c4, 4)))::8,
+            ?=, ?=,  ?=, ?=>>
         <<c1::5, c2::3>> ->
-          <<unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(bsl(c2, 2)))::8>>
+          <<main::binary,
+            unquote(fun)(enc32hex(c1))::8, unquote(fun)(enc32hex(bsl(c2, 2)))::8, ?=, ?=,
+            ?=, ?=, ?=, ?=>>
         <<>> ->
-          <<>>
+          main
       end
-      main <> maybe_pad(tail, pad?, 8, "=")
     end
   end
 
-  defp do_hex_decode32(_, <<>>, _), do: <<>>
-  defp do_hex_decode32(case, string, false),
-    do: do_hex_decode32(case, maybe_pad(string, true, 8, "="), true)
+  defp do_hex_decode32(_, <<>>), do: <<>>
 
   for {case, fun} <- [upper: :from_upper, lower: :from_lower, mixed: :from_mixed] do
-    defp do_hex_decode32(unquote(case), string, _pad?) when rem(byte_size(string), 8) == 0 do
+    defp do_hex_decode32(unquote(case), string) do
       split = byte_size(string) - 8
       <<main::size(split)-binary, rest::binary>> = string
       main = for <<c::8 <- main>>, into: <<>>, do: <<dec32hex(unquote(fun)(c))::5>>
-      tail = case rest do
+      case rest do
         <<c1::8, c2::8, ?=, ?=, ?=, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, bsr(dec32hex(unquote(fun)(c2)), 2)::3>>
+          <<main::binary, dec32hex(unquote(fun)(c1))::5,
+            bsr(dec32hex(unquote(fun)(c2)), 2)::3>>
         <<c1::8, c2::8, c3::8, c4::8, ?=, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
             dec32hex(unquote(fun)(c3))::5, bsr(dec32hex(unquote(fun)(c4)), 4)::1>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, ?=, ?=, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
             dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
             bsr(dec32hex(unquote(fun)(c5)), 1)::4>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, ?=>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
             dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
             dec32hex(unquote(fun)(c5))::5, dec32hex(unquote(fun)(c6))::5,
             bsr(dec32hex(unquote(fun)(c7)), 3)::2>>
         <<c1::8, c2::8, c3::8, c4::8, c5::8, c6::8, c7::8, c8::8>> ->
-          <<dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
+          <<main::binary,
+            dec32hex(unquote(fun)(c1))::5, dec32hex(unquote(fun)(c2))::5,
             dec32hex(unquote(fun)(c3))::5, dec32hex(unquote(fun)(c4))::5,
             dec32hex(unquote(fun)(c5))::5, dec32hex(unquote(fun)(c6))::5,
             dec32hex(unquote(fun)(c7))::5, dec32hex(unquote(fun)(c8))::5>>
         <<>> ->
-          <<>>
+          main
       end
-      main <> tail
     end
   end
-
-  defp do_hex_decode32(_, _, _),
-    do: raise ArgumentError, "incorrect padding"
 end

lib/elixir/lib/behaviour.ex

@@ -7,7 +7,8 @@ defmodule Behaviour do
   Instead of `__behaviour__(:callbacks)`, one can simply use `behaviour_info(:callbacks)`.
   """
 
-  # TODO: Deprecate by 1.4
+  # TODO: Deprecate by 1.2
+  # TODO: Remove by 2.0
 
   @doc """
   Defines a function callback according to the given type specification.

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` - include only operators
     * `:skip_operators` - skip operators
 
-  For example:
-
       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/iso.ex

@@ -1,189 +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.
-  """
-
-  @behaviour Calendar
-
-  @doc """
-  Builds and validates an ISO date.
-
-  ## Examples
-
-      iex> Calendar.ISO.date(2000, 1, 1)
-      {:ok, ~D[2000-01-01]}
-      iex> Calendar.ISO.date(2000, 13, 1)
-      {:error, :invalid_date}
-      iex> Calendar.ISO.date(2000, 2, 29)
-      {:ok, ~D[2000-02-29]}
-
-      iex> Calendar.ISO.date(2000, 2, 30)
-      {:error, :invalid_date}
-      iex> Calendar.ISO.date(2001, 2, 29)
-      {:error, :invalid_date}
-
-  """
-  def date(year, month, day) when is_integer(year) and is_integer(month) and is_integer(day) do
-    if :calendar.valid_date(year, month, day) and year <= 9999 do
-      {:ok, %Date{year: year, month: month, day: day}}
-    else
-      {:error, :invalid_date}
-    end
-  end
-
-  @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
-
-  """
-  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 """
-  Converts the given structure into a string.
-
-  It uses the ISO8601 standard except for DateTime where the
-  timezone information is added between brackets.
-  """
-  def to_string(%Date{year: year, month: month, day: day}) do
-    date_to_string(year, month, day)
-  end
-
-  def to_string(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_string(%NaiveDateTime{year: year, month: month, day: day,
-                               hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    date_to_string(year, month, day) <> " " <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_string(%DateTime{year: year, month: month, day: day, zone_abbr: zone_abbr,
-                          hour: hour, minute: minute, second: second, microsecond: microsecond,
-                          utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
-    date_to_string(year, month, day) <> " " <>
-      time_to_string(hour, minute, second, microsecond) <>
-      offset_to_string(utc_offset, std_offset, time_zone) <>
-      zone_to_string(utc_offset, std_offset, zone_abbr, time_zone)
-  end
-
-  defp date_to_string(year, month, day) do
-    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
-  end
-
-  defp time_to_string(hour, minute, second, 0) do
-    zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2) <> ":" <> zero_pad(second, 2)
-  end
-  defp time_to_string(hour, minute, second, {_, 0}) do
-    time_to_string(hour, minute, second, 0)
-  end
-  defp time_to_string(hour, minute, second, {microsecond, precision}) do
-    time_to_string(hour, minute, second, 0) <> "." <>
-      (microsecond |> zero_pad(6) |> binary_part(0, precision))
-  end
-
-  defp offset_to_string(0, 0, "Etc/UTC"), do: "Z"
-  defp offset_to_string(utc, std, _zone) do
-    total  = utc + std
-    second = abs(total)
-    minute = second |> rem(3600) |> div(60)
-    hour   = second |> div(3600)
-    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 to_iso8601(%Date{year: year, month: month, day: day}) do
-    date_to_string(year, month, day)
-  end
-
-  def to_iso8601(%Time{hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_iso8601(%NaiveDateTime{year: year, month: month, day: day,
-                                hour: hour, minute: minute, second: second, microsecond: microsecond}) do
-    date_to_string(year, month, day) <> "T" <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  def to_iso8601(%DateTime{year: year, month: month, day: day,
-                           hour: hour, minute: minute, second: second, microsecond: microsecond,
-                           utc_offset: utc_offset, std_offset: std_offset, time_zone: time_zone}) do
-    date_to_string(year, month, day) <> "T" <>
-      time_to_string(hour, minute, second, microsecond) <>
-      offset_to_string(utc_offset, std_offset, time_zone)
-  end
-
-  @doc false
-  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
-    {{0, 0}, rest}
-  end
-
-  defp parse_microsecond(<<h, t::binary>>, precision, acc) when h in ?0..?9,
-    do: parse_microsecond(t, precision + 1, <<acc::binary, h>>)
-  defp parse_microsecond(rest, precision, acc),
-    do: {acc, precision, rest}
-
-  @doc false
-  def parse_offset(""),
-    do: {nil, ""}
-  def parse_offset("Z"),
-    do: {0, ""}
-  def parse_offset("-00:00"),
-    do: :error
-  def parse_offset(<<?+, 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(_),
-    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
-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 """
@@ -126,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}`,
@@ -159,13 +159,13 @@ 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
 
@@ -263,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 """
@@ -279,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 """
@@ -311,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, ...>>}
 
   """
@@ -343,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, ...>>}
 
   """
@@ -389,8 +389,8 @@ defmodule Code do
 
   ## Examples
 
-      iex> Code.available_compiler_options
-      [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
+      Code.available_compiler_options
+      #=> [:docs, :debug_info, :ignore_module_conflict, :warnings_as_errors]
 
   """
   def available_compiler_options do
@@ -445,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 """
@@ -542,11 +542,15 @@ defmodule Code do
   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
@@ -593,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)
@@ -615,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,
@@ -49,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}
@@ -59,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,7 +13,36 @@ defmodule Dict do
   @type value :: any
   @type t :: list | map
 
-  # TODO: Deprecate every function by 1.4
+  # 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]
@@ -22,6 +51,8 @@ defmodule Dict do
     :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
@@ -82,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
 
@@ -361,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

@@ -230,7 +230,6 @@ 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"
@@ -366,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
 
@@ -386,7 +385,7 @@ defmodule Exception do
 
     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
 
@@ -464,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}"
@@ -495,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
@@ -518,18 +525,18 @@ end
 defmodule TokenMissingError do
   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: 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
 
@@ -573,14 +580,6 @@ defmodule CaseClauseError do
   end
 end
 
-defmodule WithClauseError do
-  defexception [term: nil]
-
-  def message(exception) do
-    "no with clause matching: #{inspect(exception.term)}"
-  end
-end
-
 defmodule CondClauseError do
   defexception []
 
@@ -628,66 +627,22 @@ 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
-    "function " <> Exception.format_mfa(module, function, arity) <>
-    " is undefined or private" <> did_you_mean(module, function, arity)
+    "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
-
-  @function_threshold 0.77
-  @max_suggestions 5
-
-  defp did_you_mean(module, function, _arity) do
-    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
-    fun = with ":" <> fun <- inspect(fun), do: fun
-    "      * " <> 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
 
@@ -714,13 +669,14 @@ defmodule Code.LoadError do
 end
 
 defmodule Protocol.UndefinedError do
-  defexception [protocol: nil, value: nil, description: ""]
+  defexception [protocol: nil, value: nil, description: nil]
 
   def message(exception) do
     msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.value}"
-    case exception.description do
-      "" -> msg
-      descr -> msg <> ", " <> descr
+    if exception.description do
+      msg <> ", " <> exception.description
+    else
+      msg
     end
   end
 end
@@ -752,21 +708,29 @@ 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
@@ -774,25 +738,18 @@ defmodule File.Error do
 
   def message(exception) do
     formatted = IO.iodata_to_binary(:file.format_error(exception.reason))
-    "could not #{exception.action} #{inspect(exception.path)}: #{formatted}"
+    "could not #{exception.action} #{exception.path}: #{formatted}"
   end
 end
 
 defmodule File.CopyError do
-  defexception [reason: nil, source: nil, destination: nil, 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}"
+    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
 
@@ -843,10 +800,10 @@ defmodule ErlangError do
   def normalize({:badkey, key}, stacktrace) do
     term =
       case stacktrace || :erlang.get_stacktrace do
-        [{Map, :get_and_update!, [map, _, _], _} | _] -> map
-        [{Map, :update!, [map, _, _], _} | _] -> map
-        [{:maps, :update, [_, _, map], _} | _] -> map
-        [{:maps, :get, [_, map], _} | _] -> map
+        [{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}
@@ -860,10 +817,6 @@ 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
@@ -887,11 +840,11 @@ defmodule ErlangError do
     %ErlangError{original: other}
   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

@@ -20,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
@@ -75,9 +75,9 @@ defmodule File do
   @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}
@@ -411,7 +411,7 @@ defmodule File do
   @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`.
 
@@ -430,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
-    F.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
 
@@ -485,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.
 
@@ -610,7 +609,7 @@ defmodule File 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}
@@ -637,13 +636,13 @@ defmodule File 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
@@ -657,13 +656,13 @@ defmodule File do
   defp do_cp_link(link, src, dest, callback, acc) 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, F.make_symlink/2 will fail
           _ = rm(dest)
           case F.make_symlink(link, dest) do
-            :ok -> [dest | acc]
+            :ok -> [dest|acc]
             {:error, reason} -> {:error, reason, src}
           end
         else
@@ -700,7 +699,6 @@ defmodule File do
   """
   @spec write(Path.t, iodata, [mode]) :: :ok | {:error, posix}
   def write(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
     F.write_file(IO.chardata_to_string(path), content, modes)
   end
 
@@ -709,7 +707,6 @@ defmodule File do
   """
   @spec write!(Path.t, iodata, [mode]) :: :ok | no_return
   def write!(path, content, modes \\ []) do
-    modes = normalize_modes(modes, false)
     case F.write_file(path, content, modes) do
       :ok -> :ok
       {:error, reason} ->
@@ -852,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
@@ -872,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}
@@ -922,10 +919,10 @@ defmodule File do
   end
 
   @doc ~S"""
-  Opens the given `path` according to the given list of `modes`.
+  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
@@ -933,9 +930,6 @@ defmodule File do
 
   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
@@ -951,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.
 
@@ -969,9 +963,8 @@ 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:
 
@@ -999,7 +992,7 @@ defmodule File do
   def open(path, modes \\ [])
 
   def open(path, modes) when is_list(modes) do
-    F.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) do
@@ -1228,7 +1221,7 @@ defmodule File do
 
   """
   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
 
@@ -1322,26 +1315,24 @@ defmodule File do
 
   ## Helpers
 
-  @read_ahead_size 64 * 1024
+  @read_ahead 64*1024
 
-  defp normalize_modes([:utf8 | rest], binary?) do
-    [encoding: :utf8] ++ normalize_modes(rest, binary?)
+  defp open_defaults([:char_list|t], _add_binary) do
+    open_defaults(t, false)
   end
-  defp normalize_modes([:read_ahead | rest], binary?) do
-    [read_ahead: @read_ahead_size] ++ normalize_modes(rest, binary?)
-  end
-  # TODO: Deprecate :char_list mode by v1.5
-  defp normalize_modes([mode | rest], _binary?) when mode in [:charlist, :char_list] do
-    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_pid(path),
-    do: path
-  defp maybe_to_string(path),
-    do: IO.chardata_to_string(path)
+  defp open_defaults([:utf8|t], add_binary) do
+    open_defaults([{:encoding, :utf8}|t], add_binary)
+  end
+
+  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

@@ -20,15 +20,14 @@ defmodule File.Stream do
     raw = :lists.keyfind(:encoding, 1, modes) == false
 
     modes =
-      case raw do
-        true ->
-          if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
-            [:raw | modes]
-          else
-            [:raw, :read_ahead | modes]
-          end
-        false ->
-          modes
+      if raw do
+        if :lists.keyfind(:read_ahead, 1, modes) == {:read_ahead, false} do
+          [:raw|modes]
+        else
+          [:raw, :read_ahead|modes]
+        end
+      else
+        modes
       end
 
     %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes}
@@ -38,7 +37,7 @@ defmodule File.Stream do
     def into(%{path: path, modes: modes, raw: raw} = stream) do
       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} ->

lib/elixir/lib/float.ex

@@ -8,14 +8,14 @@ defmodule Float do
   @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
@@ -155,9 +155,6 @@ defmodule Float do
       iex> Float.round(-5.5675, 3)
       -5.568
 
-      iex> Float.round(-5.5675)
-      -6.0
-
   """
   @spec round(float, 0..15) :: float
   def round(number, precision \\ 0) when is_float(number) and precision in 0..15 do
@@ -171,63 +168,84 @@ defmodule Float do
   end
 
   @doc """
-  Returns a charlist which corresponds to the text representation
-  of the given float.
+  Returns a char 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.
+  Inlined by the compiler.
 
   ## Examples
 
-      iex> Float.to_charlist(7.0)
-      '7.0'
+      iex> Float.to_char_list(7.0)
+      '7.00000000000000000000e+00'
 
   """
-  @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) :: char_list
+  def to_char_list(float) do
+    :erlang.float_to_list(float)
+  end
+
+  @doc """
+  Returns a list which corresponds to the text representation
+  of the given float.
+
+  ## 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_char_list 7.1, [decimals: 2, compact: true]
+      '7.1'
+
+  """
+  @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: Deprecate by v1.5
-  @doc false
-  def to_char_list(float), do: Float.to_charlist(float)
+  @doc """
+  Returns a binary which corresponds to the text representation
+  of `float`.
 
-  # TODO: Deprecate by v1.4
-  @doc false
-  def to_char_list(float, options) do
-    :erlang.float_to_list(float, expand_compact(options))
-  end
+  ## Options
 
-  # TODO: Deprecate by v1.4
-  @doc false
+    * `: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 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

@@ -14,7 +14,7 @@ defmodule GenEvent do
 
   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 attached to handle the
+  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.
@@ -22,14 +22,14 @@ defmodule GenEvent do
   As an example, let's have a GenEvent that accumulates messages until
   they are collected by an explicit call.
 
-      # Define an Event Handler
+      # Define a Event Handler
       defmodule LoggerHandler do
         use GenEvent
 
         # Callbacks
 
         def handle_event({:log, x}, messages) do
-          {:ok, [x | messages]}
+          {:ok, [x|messages]}
         end
 
         def handle_call(:messages, messages) do
@@ -79,7 +79,7 @@ defmodule GenEvent do
 
   ## Modes
 
-  GenEvent supports three different notifications.
+  GenEvent stream supports three different notifications.
 
   On `GenEvent.ack_notify/2`, the manager acknowledges each event,
   providing backpressure, but processing of the message happens
@@ -100,7 +100,7 @@ defmodule GenEvent do
         stream = GenEvent.stream(pid)
 
         # Discard the next 3 events
-        _ = Enum.take(stream, 3)
+        _ = Enum.drop(stream, 3)
 
         # Print all remaining events
         for event <- stream do
@@ -114,9 +114,11 @@ defmodule GenEvent do
 
   ## Learn more and compatibility
 
-  If you wish to find out more about GenEvent, the documentation and links
-  in Erlang can provide extra insight.
+  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)
 
@@ -134,7 +136,7 @@ defmodule GenEvent do
   """
 
   @doc """
-  Invoked when the handler is added to the `GenEvent` process. `add_handler/3`
+  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`.
@@ -195,7 +197,7 @@ defmodule GenEvent do
   `{: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 response to the call,
+  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`.
   """
@@ -251,7 +253,7 @@ defmodule GenEvent do
   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 to loop
+  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
@@ -262,13 +264,13 @@ defmodule GenEvent do
 
   @doc """
   Invoked to change the state of the handler when a different version of the
-  handler's module is loaded (hot code swapping) and the state's term
+  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
-  handler and `extra` is any extra data required to change the state.
+  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.
@@ -312,7 +314,7 @@ defmodule GenEvent 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)
@@ -422,7 +424,7 @@ defmodule GenEvent do
   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
+  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}
@@ -456,7 +458,7 @@ defmodule GenEvent do
     * `{:swapped, new_handler, pid}` - if the process pid has replaced the
       event handler by another
 
-    * `term` - if the event handler is removed due to an error. Which term
+    * 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
@@ -525,7 +527,7 @@ defmodule GenEvent do
   end
 
   @doc """
-  Sends an ack event notification to the event `manager`.
+  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
@@ -648,12 +650,7 @@ defmodule GenEvent 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
-        :gen.debug_options(name, options)
-      else
-        :gen.debug_options(options)
-      end
+    debug = :gen.debug_options(options)
     :proc_lib.init_ack(starter, {:ok, self()})
     loop(parent, name(name), [], debug, false)
   end
@@ -904,13 +901,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
 
@@ -926,10 +923,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
@@ -963,16 +960,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)
@@ -1062,9 +1059,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 ->
@@ -1127,7 +1124,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

@@ -22,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
@@ -31,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)

lib/elixir/lib/gen_server.ex

@@ -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
 
@@ -129,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
 
@@ -139,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
@@ -197,10 +197,10 @@ 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
@@ -229,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
@@ -245,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
@@ -265,9 +265,6 @@ defmodule GenServer do
 
   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} |
@@ -286,8 +283,8 @@ 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
@@ -296,9 +293,6 @@ defmodule GenServer do
   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} |
@@ -312,9 +306,6 @@ defmodule GenServer do
   a timeout occurs the message is `:timeout`.
 
   Return values are the same as `handle_cast/2`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:noreply, state}`.
   """
   @callback handle_info(msg :: :timeout | term, state :: term) ::
     {:noreply, new_state} |
@@ -382,28 +373,6 @@ defmodule GenServer do
     {: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 `GenServers`'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}
 
@@ -436,7 +405,7 @@ defmodule GenServer do
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour GenServer
+      @behaviour :gen_server
 
       @doc false
       def init(args) do
@@ -488,41 +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 `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 `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 `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
+  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 `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
@@ -554,13 +520,14 @@ defmodule GenServer do
   @doc """
   Stops the server with the given `reason`.
 
-  The `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
@@ -574,47 +541,45 @@ defmodule GenServer do
   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`.
 
   `handle_cast/2` will be called on the server to handle
   the request. In case the `server` is on a node which is
@@ -654,7 +619,7 @@ 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.
@@ -671,42 +636,25 @@ 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]}
@@ -717,31 +665,15 @@ defmodule GenServer do
   @doc """
   Replies to a client.
 
-  This function can be used to explicitely 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 `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
-  `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)
-      end
-
   """
   @spec reply(from, term) :: :ok
   def reply(client, reply)
@@ -756,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 name.
+  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)
@@ -795,6 +725,6 @@ defmodule GenServer do
   @compile {:inline, [nodes: 0]}
 
   defp nodes do
-    [node() | :erlang.nodes()]
+    [node()|:erlang.nodes()]
   end
 end

lib/elixir/lib/hash_dict.ex

@@ -5,8 +5,6 @@ defmodule HashDict do
   Use the `Map` module instead.
   """
 
-  # TODO: Deprecate every function by 1.4
-
   use Dict
 
   @node_bitmap 0b111
@@ -92,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
@@ -103,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}
@@ -121,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}
@@ -140,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 ->
@@ -161,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} ->
@@ -186,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
 

lib/elixir/lib/hash_set.ex

@@ -5,7 +5,7 @@ defmodule HashSet do
   Use the `MapSet` module instead.
   """
 
-  # TODO: Deprecate every function by 1.4
+  @behaviour Set
 
   @node_bitmap 0b111
   @node_shift 3
@@ -44,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
@@ -112,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
 
@@ -124,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
 
@@ -144,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
@@ -164,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)
@@ -205,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
 

lib/elixir/lib/inspect.ex

@@ -48,14 +48,14 @@ defprotocol Inspect do
   implementation directly. For example, to test Inspect.MapSet above,
   you can invoke it as:
 
-      Inspect.MapSet.inspect(MapSet.new, %Inspect.Opts{})
+      Inspect.MapSet.inspect(MapSet.new, Inspect.Opts.new)
 
   """
 
   # Handle structs in Any
   @fallback_to_any true
 
-  def inspect(term, opts)
+  def inspect(thing, opts)
 end
 
 defimpl Inspect, for: Atom do
@@ -141,16 +141,16 @@ defimpl Inspect, for: Atom do
 end
 
 defimpl Inspect, for: BitString do
-  def inspect(term, %Inspect.Opts{binaries: bins, base: base} = opts) when is_binary(term) do
-    if base == :decimal and (bins == :as_strings or (bins == :infer and String.printable?(term))) do
-      <<?", escape(term, ?")::binary, ?">>
+  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
@@ -160,7 +160,7 @@ defimpl Inspect, for: BitString do
     escape(other, char, <<>>)
   end
 
-  defp escape(<<char, t::binary>>, char, binary) do
+  defp escape(<<char, t::binary >>, char, binary) do
     escape(t, char, <<binary::binary, ?\\, char>>)
   end
   defp escape(<<?#, ?{, t::binary>>, char, binary) do
@@ -197,11 +197,11 @@ defimpl Inspect, for: BitString do
     escape(t, char, <<binary::binary, ?\\, ?v>>)
   end
   defp escape(<<h::utf8, t::binary>>, char, binary) do
-    head = <<h::utf8>>
+    head = <<h::utf8 >>
     if String.printable?(head) do
       escape(t, char, append(head, binary))
     else
-      <<byte::8, h::binary>> = head
+      <<byte::8, h::binary >> = head
       t = <<h::binary, t::binary>>
       escape(t, char, <<binary::binary, escape_char(byte)::binary>>)
     end
@@ -241,35 +241,30 @@ defimpl Inspect, for: BitString do
 
   ## Bitstrings
 
-  defp inspect_bitstring("", _opts) do
-    "<<>>"
-  end
-
   defp inspect_bitstring(bitstring, opts) do
-    nest surround("<<", each_bit(bitstring, opts.limit, opts), ">>"), 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
 
   defp decrement(:infinity), do: :infinity
@@ -279,27 +274,14 @@ end
 defimpl Inspect, for: List do
   def inspect([], _opts), do: "[]"
 
-  # TODO: Deprecate :char_lists and :as_char_lists keys in v1.5
-  def inspect(term, %Inspect.Opts{charlists: lists, char_lists: lists_deprecated} = opts) do
-    lists =
-      if lists == :infer and lists_deprecated != :infer do
-        case lists_deprecated do
-          :as_char_lists ->
-            :as_charlists
-          _ ->
-            lists_deprecated
-        end
-      else
-        lists
-      end
-
+  def inspect(thing, %Inspect.Opts{char_lists: lists} = opts) do
     cond do
-      lists == :as_charlists or (lists == :infer and printable?(term)) ->
-        <<?', Inspect.BitString.escape(IO.chardata_to_string(term), ?')::binary, ?'>>
-      keyword?(term) ->
-        surround_many("[", term, "]", opts, &keyword/2)
+      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("[", term, "]", opts, &to_doc/2)
+        surround_many("[", thing, "]", opts, &to_doc/2)
     end
   end
 
@@ -313,7 +295,7 @@ defimpl Inspect, for: List do
 
   @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
@@ -323,15 +305,15 @@ defimpl Inspect, for: List do
   def keyword?(_other), do: false
 
   @doc false
-  def printable?([c | cs]) when c in 32..126, do: printable?(cs)
-  def printable?([?\n | cs]), do: printable?(cs)
-  def printable?([?\r | cs]), do: printable?(cs)
-  def printable?([?\t | cs]), do: printable?(cs)
-  def printable?([?\v | cs]), do: printable?(cs)
-  def printable?([?\b | cs]), do: printable?(cs)
-  def printable?([?\f | cs]), do: printable?(cs)
-  def printable?([?\e | cs]), do: printable?(cs)
-  def printable?([?\a | cs]), do: printable?(cs)
+  def printable?([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
 
@@ -380,8 +362,8 @@ defimpl Inspect, for: Map do
 end
 
 defimpl Inspect, for: Integer do
-  def inspect(term, %Inspect.Opts{base: base}) do
-    Integer.to_string(term, base_to_value(base))
+  def inspect(thing, %Inspect.Opts{base: base}) do
+    Integer.to_string(thing, base_to_value(base))
     |> prepend_prefix(base)
   end
 
@@ -406,8 +388,8 @@ defimpl Inspect, for: Integer do
 end
 
 defimpl Inspect, for: Float do
-  def inspect(term, _opts) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
+  def inspect(thing, _opts) do
+    IO.iodata_to_binary(:io_lib_format.fwrite_g(thing))
   end
 end
 
@@ -472,7 +454,7 @@ defimpl Inspect, for: Function do
     if fun_info[:type] == :external and fun_info[:env] == [] do
       "&#{Inspect.Atom.inspect(mod)}.#{fun_info[:name]}/#{fun_info[:arity]}"
     else
-      case Atom.to_charlist(mod) do
+      case Atom.to_char_list(mod) do
         'elixir_compiler_' ++ _ ->
           if function_exported?(mod, :__RELATIVE__, 0) do
             "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"

lib/elixir/lib/inspect/algebra.ex

@@ -15,39 +15,35 @@ 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, and lists, does not apply to strings nor charlists, defaults
+      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` - print integers as :binary, :octal, :decimal, or :hex, defaults
-      to :decimal. When inspecting binaries any `:base` other than `:decimal`
-      implies `binaries: :as_binaries`.
+      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
 
   """
 
-  # TODO: Deprecate char_lists key by v1.5
   defstruct structs: true,
             binaries: :infer,
-            charlists: :infer,
             char_lists: :infer,
             limit: 50,
             width: 80,
@@ -55,11 +51,9 @@ defmodule Inspect.Opts do
             pretty: false,
             safe: true
 
-  # TODO: Deprecate char_lists key and :as_char_lists value by v1.5
   @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,
                width: pos_integer | :infinity,
@@ -83,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
@@ -126,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
@@ -422,7 +416,7 @@ defmodule Inspect.Algebra do
   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))
+  def fold_doc([d|ds], fun), do: fun.(d, fold_doc(ds, fun))
 
   # Elixir conveniences
 
@@ -494,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})
@@ -524,7 +518,7 @@ defmodule Inspect.Algebra do
   document to fit in the given width.
   """
   @spec format(t, non_neg_integer | :infinity) :: iodata
-  def format(d, w) when w == :infinity or w >= 0 do
+  def format(d, w) do
     format(w, 0, [{0, default_mode(w), doc_group(d)}])
   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,93 +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 """
-  Returns the ordered digits for the given non-negative `integer`.
+  Returns the ordered digits for the given non-negative integer.
 
-  An optional `base` value may be provided representing the radix for the returned
-  digits. This one can be an integer >= 2.
+  An optional base value may be provided representing the radix for the returned
+  digits.
 
   ## Examples
 
       iex> Integer.digits(101)
       [1, 0, 1]
 
-      iex> Integer.digits(170, 2)
-      [1, 0, 1, 0, 1, 0, 1, 0]
+      iex> Integer.digits(58127, 2)
+      [1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1]
 
   """
-  @spec digits(non_neg_integer, pos_integer) :: [non_neg_integer, ...]
-  def digits(integer, base \\ 10)
-      when is_integer(integer) and integer >= 0 and is_integer(base) and base >= 2 do
-    do_digits(integer, base, [])
+  @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(1, _base, []), do: [1]
-  defp do_digits(base, base, []), do: [1, 0]
+  defp do_digits(0, _base, []),  do: [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]
+  defp do_digits(n, base, acc)  do
+    do_digits div(n, base), base, [rem(n, base) | acc]
   end
 
   @doc """
-  Returns the integer represented by the ordered `digits`.
+  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.
+  An optional base value may be provided representing the radix for the digits.
 
   ## 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, []), do: 0
-  defp do_undigits([0], _base, []), do: 0
-  defp do_undigits([1], _base, []), do: 1
-  defp do_undigits([1, 0], base, []), do: base
   defp do_undigits([], _base, acc), do: acc
   defp do_undigits([digit | 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")
@@ -164,21 +134,18 @@ defmodule Integer do
   @spec parse(binary, 2..36) :: {integer, binary} | :error | no_return
   def parse(binary, base \\ 10)
 
-  def parse("", base) when base in 2..36,
-    do: :error
-
-  def parse(binary, base) when is_binary(binary) and base in 2..36 do
+  def parse(binary, base) when is_integer(base) and base in 2..36 do
     parse_in_base(binary, base)
   end
 
-  def parse(binary, base) when is_binary(binary) do
+  def parse(_, base) do
     raise ArgumentError, "invalid base #{base}"
   end
 
   defp parse_in_base("-" <> bin, base) do
     case do_parse(bin, base) do
-      {number, remainder} -> {-number, remainder}
       :error -> :error
+      {number, remainder} -> {-number, remainder}
     end
   end
 
@@ -186,8 +153,8 @@ defmodule Integer do
     do_parse(bin, base)
   end
 
-  defp parse_in_base(binary, base) when is_binary(binary) do
-    do_parse(binary, base)
+  defp parse_in_base(bin, base) when is_binary(bin) do
+    do_parse(bin, base)
   end
 
   defp do_parse(<<char, rest::binary>>, base) do
@@ -198,15 +165,13 @@ defmodule Integer do
     end
   end
 
-  defp do_parse(_, _) do
-    :error
-  end
+  defp do_parse(_, _), do: :error
 
-  defp do_parse(<<char, rest::binary>> = bin, base, acc) do
+  defp do_parse(<<char, rest::binary>>, base, acc) do
     if valid_digit_in_base?(char, base) do
       do_parse(rest, base, base * acc + parse_digit(char, base))
     else
-      {acc, bin}
+      {acc, <<char, rest::binary>>}
     end
   end
 
@@ -232,7 +197,7 @@ defmodule Integer do
 
   @doc """
   Returns a binary which corresponds to the text representation
-  of `integer`.
+  of `some_integer`.
 
   Inlined by the compiler.
 
@@ -241,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.
 
@@ -269,69 +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
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  @spec to_char_list(integer) :: charlist
-  def to_char_list(integer), do: Integer.to_charlist(integer)
 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.
   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,
   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
@@ -47,11 +47,8 @@ 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:
 
@@ -67,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 \\ group_leader(), line_or_chars)
+  def read(device \\ group_leader, chars_or_line)
 
   def read(device, :all) do
     do_read_all(map_dev(device), "")
@@ -77,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
 
@@ -90,11 +87,8 @@ defmodule IO do
   end
 
   @doc """
-  Reads from the IO `device`. The operation is Unicode unsafe.
-
-  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:
 
@@ -109,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 \\ group_leader(), line_or_chars)
+  def binread(device \\ group_leader, chars_or_line)
 
   def binread(device, :all) do
     do_binread_all(map_dev(device), "")
@@ -126,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
@@ -143,18 +137,18 @@ 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
@@ -163,13 +157,12 @@ defmodule IO do
   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}
@@ -178,60 +171,18 @@ defmodule IO do
   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 \\ group_leader(), item) do
-    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
+    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.
+  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
@@ -250,7 +201,7 @@ defmodule IO do
   end
 
   @doc """
-  Inspects `item` according to the given options using the IO `device`.
+  Inspects the item with options using the given device.
 
   See `Inspect.Opts` for a full list of options.
   """
@@ -263,34 +214,10 @@ defmodule IO do
   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(group_leader, 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
@@ -300,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 """
-  Reads a line from the IO `device`.
+  Reads a line from the IO device.
 
   It returns:
 
@@ -325,8 +269,7 @@ 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 \\ group_leader(), prompt) do
@@ -334,16 +277,16 @@ defmodule IO do
   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
@@ -358,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
 
@@ -393,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
 
@@ -404,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
@@ -414,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.
@@ -436,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>>
@@ -456,7 +398,7 @@ defmodule IO do
 
   ## Examples
 
-      iex> IO.iodata_length([1, 2 | <<3, 4>>])
+      iex> IO.iodata_length([1, 2|<<3, 4>>])
       4
 
   """
@@ -466,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} ->
@@ -478,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} ->
@@ -491,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
 
-  @typep ansicode :: atom
-  @typep 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.
@@ -186,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"""
@@ -206,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
@@ -222,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

@@ -43,7 +43,7 @@ defmodule IO.ANSI.Docs do
     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
   end
@@ -58,7 +58,7 @@ defmodule IO.ANSI.Docs do
     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
 
@@ -68,19 +68,19 @@ defmodule IO.ANSI.Docs do
 
   defp process(["# " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h1(String.trim(heading), options)
+    write_h1(String.strip(heading), options)
     process(rest, [], "", options)
   end
 
   defp process(["## " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h2(String.trim(heading), options)
+    write_h2(String.strip(heading), options)
     process(rest, [], "", options)
   end
 
   defp process(["### " <> heading | rest], text, indent, options) do
     write_text(text, indent, options)
-    write_h3(String.trim(heading), indent, options)
+    write_h3(String.strip(heading), indent, options)
     process(rest, [], "", options)
   end
 
@@ -153,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), [])
@@ -197,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
@@ -229,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
@@ -250,7 +250,7 @@ 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
 
@@ -285,8 +285,8 @@ defmodule IO.ANSI.Docs do
 
   defp split_into_columns(line, options) do
     line
-    |> String.trim("|")
-    |> String.trim()
+    |> String.strip(?|)
+    |> String.strip()
     |> String.split(~r/\s\|\s/)
     |> Enum.map(&render_column(&1, options))
   end
@@ -379,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 == [] ->
@@ -393,7 +393,7 @@ defmodule IO.ANSI.Docs do
 
       # Otherwise
       true ->
-        {Enum.reverse(acc), [word | words]}
+        {Enum.reverse(acc), [word|words]}
     end
   end
 
@@ -466,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

@@ -111,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} ->
@@ -125,18 +125,18 @@ defmodule Kernel.CLI do
 
   @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
                      :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
-                     :elixir_def, :elixir_map]
+                     :elixir_def]
 
-  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
@@ -145,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
 
@@ -203,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)
@@ -245,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)
@@ -284,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)
@@ -390,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, ",")}"}

lib/elixir/lib/kernel/error_handler.ex

@@ -4,34 +4,37 @@ defmodule Kernel.ErrorHandler do
   @moduledoc false
 
   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
 
   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
 
-  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
 
-  # 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,9 @@
 # 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.
 defmodule Kernel.LexicalTracker do
@@ -9,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
@@ -51,8 +56,8 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def add_import(pid, module, fas, line, warn) 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
@@ -61,18 +66,13 @@ defmodule Kernel.LexicalTracker do
   end
 
   @doc false
-  def remote_reference(pid, module, mode) 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) do
-    :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
-  end
-
-  @doc false
-  def import_dispatch(pid, module, fa, line, mode) do
-    :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
+  def import_dispatch(pid, module) do
+    :gen_server.cast(pid, {:import_dispatch, module})
   end
 
   @doc false
@@ -91,89 +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}}
+    {: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_cast({:remote_reference, module, mode}, state) do
-    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
+  def handle_cast({:alias_dispatch, module}, {d, dest}) do
+    add_dispatch(d, module, :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}}
+  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({: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}
+  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({: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) when is_atom(module) do
-    directives =
-      for {{:import, {import_module, _, _}}, _} = directive <- state.directives,
-          module != import_module,
-          do: directive,
-          into: %{}
-
-    directives = add_directive(directives, module, line, warn, :import)
-
-    directives =
-      Enum.reduce fas, directives, fn {function, arity}, directives ->
-        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
@@ -186,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,13 +20,6 @@ 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
 
@@ -59,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.
@@ -81,112 +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.process_flag(:error_handler, Kernel.ErrorHandler)
 
         exit(try do
           _ = if output do
-            :elixir_compiler.file_to_path(file, output)
+            :elixir_compiler.file_to_path(h, output)
           else
-            :elixir_compiler.file(file, Keyword.get(options, :dest))
+            :elixir_compiler.file(h, Keyword.get(options, :dest))
           end
-          {:shutdown, file}
+          {: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 type). This may not always be
-    # true though: for example, if there is a macro injecting code into
-    # multiple modules and such code becomes faulty, now multiple modules
-    # are waiting on the same module required by the faulty code. However,
-    # since we need to pick something to be first, the one with fewer edges
-    # sounds like a sane choice.
-    entries =
-      entries
-      |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
-      |> Enum.sort_by(&length(elem(&1, 1)))
-      |> Enum.find_value([], &elem(&1, 1))
-
-    case entries do
-      [] -> handle_deadlock(waiting, queued)
-      _  -> spawn_compilers(%{state | entries: entries})
+  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
@@ -196,102 +149,63 @@ 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.
-        waiting =
-          if :lists.any(&match?({^kind, ^on}, &1), result) 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)
+
+        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, down_pid)
-
         # Sometimes we may have spurious entries in the waiting
         # list because someone invoked try/rescue UndefinedFunctionError
         new_entries = List.delete(entries, down_pid)
         new_queued  = List.keydelete(queued, down_pid, 0)
         new_waiting = List.keydelete(waiting, down_pid, 1)
-        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
+        spawn_compilers(new_entries, original, output, options, new_waiting, new_queued, schedulers, result)
 
       {:DOWN, down_ref, :process, _down_pid, reason} ->
-        handle_failure(down_ref, reason, queued)
-        wait_for_messages(state)
+        handle_failure(down_ref, reason, entries, waiting, queued)
+        wait_for_messages(entries, original, output, options, waiting, queued, schedulers, result)
     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_failure(file, {:failure, :error, error, stacktrace})
-
-        {file, on}
-      end
-
-    IO.puts """
-
-    Compilation failed because of a deadlock between files.
-    The following files depended on the following modules:
-    """
-
-    max =
-      deadlock
-      |> Enum.map(& &1 |> elem(0) |> String.length)
-      |> Enum.max
-
-    for {file, mod} <- deadlock do
-      IO.puts ["  ", String.pad_leading(file, max), " => " | inspect(mod)]
-    end
-
-    IO.puts ""
-    exit({:shutdown, 1})
-  end
-
-  defp handle_failure(ref, reason, queued) do
+  defp handle_failure(ref, reason, entries, waiting, queued) do
     if file = find_failure(ref, queued) do
       print_failure(file, reason)
-      for {pid, _, _, _} <- queued do
-        Process.exit(pid, :kill)
+
+      if all_missing?(entries, waiting, queued) do
+        collect_failures(queued, length(queued) - 1)
       end
+
+      Enum.each queued, fn {child, _, _} ->
+        Process.exit(child, :kill)
+      end
+
       exit({:shutdown, 1})
     end
   end
 
   defp find_failure(ref, queued) do
     case List.keyfind(queued, ref, 1) do
-      {_child, ^ref, file, _timer_ref} -> file
+      {_child, ^ref, file} -> file
       _ -> nil
     end
   end
@@ -312,33 +226,39 @@ defmodule Kernel.ParallelCompiler do
 
   @elixir_internals [:elixir, :elixir_exp, :elixir_compiler, :elixir_module, :elixir_clauses,
                      :elixir_translator, :elixir_expand, :elixir_lexical, :elixir_exp_clauses,
-                     :elixir_def, :elixir_map, Kernel.ErrorHandler]
+                     :elixir_def]
 
-  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([h | t]) do
-    [h | prune_stacktrace(t)]
+  defp prune_stacktrace([h|t]) do
+    [h|prune_stacktrace(t)]
   end
 
   defp prune_stacktrace([]) do
     []
   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 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,22 +23,22 @@ 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([h | t], 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)
@@ -61,48 +52,34 @@ defmodule Kernel.ParallelRequire do
       end)
     end
 
-    spawn_requires(t, [{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
       {:DOWN, ref, :process, pid, status} ->
         tuple = {pid, ref}
         if tuple in waiting do
-          waiting = List.delete(waiting, tuple)
-
           case status do
             {:required, mods, file} ->
-              if each_file_callback = callbacks[:each_file] do
-                each_file_callback.(file)
-              end
-
-              spawn_requires(files, waiting, callbacks, schedulers, mods ++ result)
-
+              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
-        else
-          spawn_requires(files, waiting, callbacks, schedulers, result)
         end
-
-      {:module_available, child, ref, file, module, binary} ->
-        if each_module_callback = callbacks[:each_module] do
-          each_module_callback.(file, module, binary)
-        end
-
+        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
 end

lib/elixir/lib/kernel/special_forms.ex

@@ -1,10 +1,10 @@
 defmodule Kernel.SpecialForms do
   @moduledoc """
   Special forms are the basic building blocks of Elixir, and therefore
-  cannot be overridden by the developer.
+  they cannot be overridden by the developer.
 
   We define them in this module. Some of these forms are lexical (like
-  `alias/2`, `case/2`, etc). The macros `{}` and `<<>>` are also special
+  `alias`, `case`, etc). The macros `{}` and `<<>>` are also special
   forms used to define tuple and binary data structures respectively.
 
   This module also documents Elixir's pseudo variables (`__ENV__`,
@@ -12,20 +12,12 @@ defmodule Kernel.SpecialForms do
   information about Elixir's compilation environment and can only
   be read, never assigned to.
 
-  Finally, it also documents two special forms, `__block__` and
+  Finally, it also documents 2 special forms, `__block__` and
   `__aliases__`, which are not intended to be called directly by the
   developer but they appear in quoted contents since they are essential
   in Elixir's constructs.
   """
 
-  defmacrop error!(args) do
-    quote do
-      _ = unquote(args)
-      message = "Elixir's special forms are expanded by the compiler and must not be invoked directly"
-      :erlang.error(RuntimeError.exception(message))
-    end
-  end
-
   @doc """
   Creates a tuple.
 
@@ -43,13 +35,11 @@ defmodule Kernel.SpecialForms do
       iex> {1, 2, 3}
       {1, 2, 3}
 
-      iex> quote do
-      ...>   {1, 2, 3}
-      ...> end
+      iex> quote do: {1, 2, 3}
       {:{}, [], [1, 2, 3]}
 
   """
-  defmacro unquote(:{})(args), do: error!([args])
+  defmacro unquote(:{})(args)
 
   @doc """
   Creates a map.
@@ -85,7 +75,7 @@ defmodule Kernel.SpecialForms do
       iex> map.a
       :b
 
-  Note that the `.` operator expects the key `:a` to exist in the map.
+  Note that the `.` operator expects the field to exist in the map.
   If not, an `ArgumentError` is raised.
 
   ## Update syntax
@@ -102,16 +92,14 @@ defmodule Kernel.SpecialForms do
   ## AST representation
 
   Regardless if `=>` or the keywords syntax is used, Maps are
-  always represented internally as a list of two-element tuples
+  always represented internally as a list of two-items tuples
   for simplicity:
 
-      iex> quote do
-      ...>   %{"a" => :b, c: :d}
-      ...> end
+      iex> quote do: %{"a" => :b, c: :d}
       {:%{}, [], [{"a", :b}, {:c, :d}]}
 
   """
-  defmacro unquote(:%{})(args), do: error!([args])
+  defmacro unquote(:%{})(args)
 
   @doc """
   Creates a struct.
@@ -120,7 +108,17 @@ defmodule Kernel.SpecialForms do
   default values for keys, tags to be used in polymorphic
   dispatches and compile time assertions.
 
-  Structs are usually defined with the `Kernel.defstruct/1` macro:
+  To define a struct, you just need to implement the `__struct__/0`
+  function in a module:
+
+      defmodule User do
+        def __struct__ do
+          %{name: "john", age: 27}
+        end
+      end
+
+  In practice though, structs are usually defined with the
+  `Kernel.defstruct/1` macro:
 
       defmodule User do
         defstruct name: "john", age: 27
@@ -130,7 +128,7 @@ defmodule Kernel.SpecialForms do
 
       %User{}
 
-  Underneath a struct is just a map with a `:__struct__` key
+  Underneath a struct is just a map with a `__struct__` field
   pointing to the `User` module:
 
       %User{} == %{__struct__: User, name: "john", age: 27}
@@ -141,6 +139,13 @@ defmodule Kernel.SpecialForms do
 
       %User{full_name: "john doe"}
 
+  Note that a struct specifies a minimum set of keys required
+  for operations. Other keys can be added to structs via the
+  regular map operations:
+
+      user = %User{}
+      Map.put(user, :a_non_struct_key, :value)
+
   An update operation specific for structs is also available:
 
       %User{user | age: 28}
@@ -153,10 +158,10 @@ defmodule Kernel.SpecialForms do
   any of the protocols implemented for maps. Check
   `Kernel.defprotocol/2` for more information on how structs
   can be used with protocols for polymorphic dispatch. Also
-  see `Kernel.struct/2` and `Kernel.struct!/2` for examples on
-  how to create and update structs dynamically.
+  see `Kernel.struct/2` for examples on how to create and update
+  structs dynamically.
   """
-  defmacro unquote(:%)(struct, map), do: error!([struct, map])
+  defmacro unquote(:%)(struct, map)
 
   @doc """
   Defines a new bitstring.
@@ -187,7 +192,7 @@ defmodule Kernel.SpecialForms do
       <<1, 2, 3>>
 
   Elixir also accepts by default the segment to be a literal
-  string or a literal charlist, which are by default expanded to integers:
+  string or a literal char list, which are by default expanded to integers:
 
       iex> <<0, "foo">>
       <<0, 102, 111, 111>>
@@ -204,8 +209,8 @@ defmodule Kernel.SpecialForms do
       iex> <<102, rest::binary>>
       "foo"
 
-  The utf8, utf16, and utf32 types are for Unicode codepoints. They
-  can also be applied to literal strings and charlists:
+  The utf8, utf16, and utf32 types are for unicode codepoints. They
+  can also be applied to literal strings and char lists:
 
       iex> <<"foo"::utf16>>
       <<0, 102, 0, 111, 0, 111>>
@@ -228,7 +233,7 @@ defmodule Kernel.SpecialForms do
   ### Unit and Size
 
   The length of the match is equal to the `unit` (a number of bits) times the
-  `size` (the number of repeated segments of length `unit`).
+  `size` (the number of repeated segnments of length `unit`).
 
   Type      | Default Unit
   --------- | ------------
@@ -355,7 +360,7 @@ defmodule Kernel.SpecialForms do
   check out
   [Erlang's Efficiency Guide on handling binaries](http://www.erlang.org/doc/efficiency_guide/binaryhandling.html).
   """
-  defmacro unquote(:<<>>)(args), do: error!([args])
+  defmacro unquote(:<<>>)(args)
 
   @doc """
   Defines a remote call or an alias.
@@ -408,9 +413,7 @@ defmodule Kernel.SpecialForms do
   forms. When the right side starts with a lowercase letter (or
   underscore):
 
-      iex> quote do
-      ...>   String.downcase("FOO")
-      ...> end
+      iex> quote do: String.downcase("FOO")
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
   Notice we have an inner tuple, containing the atom `:.` representing
@@ -424,9 +427,7 @@ defmodule Kernel.SpecialForms do
   alias `String` and the atom `:downcase`. The second argument is **always**
   an atom:
 
-      iex> quote do
-      ...>   String."downcase"("FOO")
-      ...> end
+      iex> quote do: String."downcase"("FOO")
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
   The tuple containing `:.` is wrapped in another tuple, which actually
@@ -434,12 +435,10 @@ defmodule Kernel.SpecialForms do
 
   When the right side is an alias (i.e. starts with uppercase), we get instead:
 
-      iex> quote do
-      ...>   Hello.World
-      ...> end
+      iex> quote do: Hello.World
       {:__aliases__, [alias: false], [:Hello, :World]}
 
-  We go into more details about aliases in the `__aliases__` special form
+  We got into more details about aliases in the `__aliases__` special form
   documentation.
 
   ## Unquoting
@@ -447,9 +446,7 @@ defmodule Kernel.SpecialForms do
   We can also use unquote to generate a remote call in a quoted expression:
 
       iex> x = :downcase
-      iex> quote do
-      ...>   String.unquote(x)("FOO")
-      ...> end
+      iex> quote do: String.unquote(x)("FOO")
       {{:., [], [{:__aliases__, [alias: false], [:String]}, :downcase]}, [], ["FOO"]}
 
   Similar to `Kernel."HELLO"`, `unquote(x)` will always generate a remote call,
@@ -457,21 +454,19 @@ defmodule Kernel.SpecialForms do
   one needs to rely on `Module.concat/2`:
 
       iex> x = Sample
-      iex> quote do
-      ...>   Module.concat(String, unquote(x))
-      ...> end
+      iex> quote do: Module.concat(String, unquote(x))
       {{:., [], [{:__aliases__, [alias: false], [:Module]}, :concat]}, [],
        [{:__aliases__, [alias: false], [:String]}, Sample]}
 
   """
-  defmacro unquote(:.)(left, right), do: error!([left, right])
+  defmacro unquote(:.)(left, right)
 
   @doc """
-  `alias/2` is used to setup aliases, often useful with modules names.
+  `alias` is used to setup aliases, often useful with modules names.
 
   ## Examples
 
-  `alias/2` can be used to setup an alias for any module:
+  `alias` can be used to setup an alias for any module:
 
       defmodule Math do
         alias MyKeyword, as: Keyword
@@ -498,7 +493,7 @@ defmodule Kernel.SpecialForms do
 
   ## Lexical scope
 
-  `import/2`, `require/2` and `alias/2` are called directives and all
+  `import`, `require` and `alias` are called directives and all
   have lexical scope. This means you can set up aliases inside
   specific functions and it won't affect the overall scope.
 
@@ -514,7 +509,7 @@ defmodule Kernel.SpecialForms do
   Both warning behaviours could be changed by explicitly
   setting the `:warn` option to `true` or `false`.
   """
-  defmacro alias(module, opts), do: error!([module, opts])
+  defmacro alias(module, opts)
 
   @doc """
   Requires a given module to be compiled and loaded.
@@ -525,7 +520,7 @@ defmodule Kernel.SpecialForms do
   the only exception is if you want to use the macros from a module.
   In such cases, you need to explicitly require them.
 
-  Let's suppose you created your own `if/2` implementation in the module
+  Let's suppose you created your own `if` implementation in the module
   `MyMacros`. If you want to invoke it, you need to first explicitly
   require the `MyMacros`:
 
@@ -538,16 +533,16 @@ defmodule Kernel.SpecialForms do
 
   ## Alias shortcut
 
-  `require/2` also accepts `as:` as an option so it automatically sets
-  up an alias. Please check `alias/2` for more information.
+  `require` also accepts `as:` as an option so it automatically sets
+  up an alias. Please check `alias` for more information.
 
   """
-  defmacro require(module, opts), do: error!([module, opts])
+  defmacro require(module, opts)
 
   @doc """
   Imports functions and macros from other modules.
 
-  `import/2` allows one to easily access functions or macros from
+  `import` allows one to easily access functions or macros from
   others modules without using the qualified name.
 
   ## Examples
@@ -581,7 +576,7 @@ defmodule Kernel.SpecialForms do
       import List, only: [flatten: 1]
       import String, except: [split: 2]
 
-  Notice that calling `except` for a previously declared `import/2`
+  Notice that calling `except` for a previously declared `import`
   simply filters the previously imported elements. For example:
 
       import List, only: [flatten: 1, keyfind: 4]
@@ -600,7 +595,7 @@ defmodule Kernel.SpecialForms do
 
   ## Lexical scope
 
-  It is important to notice that `import/2` is lexical. This means you
+  It is important to notice that `import` is lexical. This means you
   can import specific macros inside specific functions:
 
       defmodule Math do
@@ -608,7 +603,7 @@ defmodule Kernel.SpecialForms do
           # 1) Disable "if/2" from Kernel
           import Kernel, except: [if: 2]
 
-          # 2) Require the new "if/2" macro from MyMacros
+          # 2) Require the new "if" macro from MyMacros
           import MyMacros
 
           # 3) Use the new macro
@@ -641,7 +636,7 @@ defmodule Kernel.SpecialForms do
   if an ambiguous call to `foo/1` is actually made; that is, the
   errors are emitted lazily, not eagerly.
   """
-  defmacro import(module, opts), do: error!([module, opts])
+  defmacro import(module, opts)
 
   @doc """
   Returns the current environment information as a `Macro.Env` struct.
@@ -649,7 +644,7 @@ defmodule Kernel.SpecialForms do
   In the environment you can access the current filename,
   line numbers, set up aliases, the current function and others.
   """
-  defmacro __ENV__, do: error!([])
+  defmacro __ENV__
 
   @doc """
   Returns the current module name as an atom or `nil` otherwise.
@@ -657,15 +652,15 @@ defmodule Kernel.SpecialForms do
   Although the module can be accessed in the `__ENV__`, this macro
   is a convenient shortcut.
   """
-  defmacro __MODULE__, do: error!([])
+  defmacro __MODULE__
 
   @doc """
-  Returns the absolute path of the directory of the current file as a binary.
+  Returns the current directory as a binary.
 
   Although the directory can be accessed as `Path.dirname(__ENV__.file)`,
   this macro is a convenient shortcut.
   """
-  defmacro __DIR__, do: error!([])
+  defmacro __DIR__
 
   @doc """
   Returns the current calling environment as a `Macro.Env` struct.
@@ -673,7 +668,7 @@ defmodule Kernel.SpecialForms do
   In the environment you can access the filename, line numbers,
   set up aliases, the function and others.
   """
-  defmacro __CALLER__, do: error!([])
+  defmacro __CALLER__
 
   @doc """
   Accesses an already bound variable in match clauses. Also known as the pin operator.
@@ -705,12 +700,12 @@ defmodule Kernel.SpecialForms do
       1
 
   """
-  defmacro ^(var), do: error!([var])
+  defmacro ^(var)
 
   @doc """
   Matches the value on the right against the pattern on the left.
   """
-  defmacro left = right, do: error!([left, right])
+  defmacro left = right
 
   @doc """
   Used by types and bitstrings to specify types.
@@ -727,21 +722,19 @@ defmodule Kernel.SpecialForms do
 
       <<int::integer-little, rest::bits>> = bits
 
-  Read the documentation on the `Typespec` page and
+  Read the documentation for `Kernel.Typespec` and
   `<<>>/1` for more information on typespecs and
   bitstrings respectively.
   """
-  defmacro left :: right, do: error!([left, right])
+  defmacro left :: right
 
   @doc ~S"""
   Gets the representation of any expression.
 
   ## Examples
 
-      iex> quote do
-      ...>   sum(1, 2, 3)
-      ...> end
-      {:sum, [], [1, 2, 3]}
+      quote do: sum(1, 2, 3)
+      #=> {:sum, [], [1, 2, 3]}
 
   ## Explanation
 
@@ -772,14 +765,10 @@ defmodule Kernel.SpecialForms do
       quote. Read the Stacktrace information section below for more
       information.
 
-    * `:generated` - marks the given chunk as generated so it does not emit warnings.
-      Currently it only works on special forms (for example, you can annotate a `case`
-      but not an `if`).
-
     * `:context` - sets the resolution context.
 
     * `:bind_quoted` - passes a binding to the macro. Whenever a binding is
-      given, `unquote/1` is automatically disabled.
+      given, `unquote` is automatically disabled.
 
   ## Quote literals
 
@@ -795,7 +784,7 @@ defmodule Kernel.SpecialForms do
 
   ## Quote and macros
 
-  `quote/2` is commonly used with macros for code generation. As an exercise,
+  `quote` is commonly used with macros for code generation. As an exercise,
   let's define a macro that multiplies a number by itself (squared). Note
   there is no reason to define such as a macro (and it would actually be
   seen as a bad practice), but it is simple enough that it allows us to focus
@@ -863,7 +852,7 @@ defmodule Kernel.SpecialForms do
   once.
 
   In fact, this pattern is so common that most of the times you will want
-  to use the `bind_quoted` option with `quote/2`:
+  to use the `bind_quoted` option with `quote`:
 
       defmodule Math do
         defmacro squared(x) do
@@ -903,9 +892,7 @@ defmodule Kernel.SpecialForms do
 
       defmodule Hygiene do
         defmacro no_interference do
-          quote do
-            a = 1
-          end
+          quote do: a = 1
         end
       end
 
@@ -923,9 +910,7 @@ defmodule Kernel.SpecialForms do
 
       defmodule NoHygiene do
         defmacro interference do
-          quote do
-            var!(a) = 1
-          end
+          quote do: var!(a) = 1
         end
       end
 
@@ -986,9 +971,7 @@ defmodule Kernel.SpecialForms do
         alias Map, as: M
 
         defmacro no_interference do
-          quote do
-            M.new
-          end
+          quote do: M.new
         end
       end
 
@@ -1006,9 +989,7 @@ defmodule Kernel.SpecialForms do
         alias Map, as: M
 
         defmacro no_interference do
-          quote do
-            M.new
-          end
+          quote do: M.new
         end
       end
 
@@ -1022,17 +1003,13 @@ defmodule Kernel.SpecialForms do
       defmodule Hygiene do
         # This will expand to Elixir.Nested.hello
         defmacro no_interference do
-          quote do
-            Nested.hello
-          end
+          quote do: Nested.hello
         end
 
         # This will expand to Nested.hello for
         # whatever is Nested in the caller
         defmacro interference do
-          quote do
-            alias!(Nested).hello
-          end
+          quote do: alias!(Nested).hello
         end
       end
 
@@ -1057,7 +1034,7 @@ defmodule Kernel.SpecialForms do
       defmodule Hygiene do
         defmacrop get_length do
           quote do
-            length([1, 2, 3])
+            length([1,2,3])
           end
         end
 
@@ -1069,7 +1046,7 @@ defmodule Kernel.SpecialForms do
 
       Hygiene.return_length #=> 3
 
-  Notice how `return_length` returns 3 even though the `length/1`
+  Notice how `return_length` returns 5 even though the `length/1`
   function is not imported. In fact, even if `return_length`
   imported a function with the same name and arity from another
   module, it wouldn't affect the function result:
@@ -1126,11 +1103,6 @@ defmodule Kernel.SpecialForms do
         defadd
       end
 
-      require Sample
-      Sample.add(:one, :two)
-      #=> ** (ArithmeticError) bad argument in arithmetic expression
-      #=>     adder.ex:5: Sample.add/2
-
   When using `location: :keep` and invalid arguments are given to
   `Sample.add/2`, the stacktrace information will point to the file
   and line inside the quote. Without `location: :keep`, the error is
@@ -1210,7 +1182,7 @@ defmodule Kernel.SpecialForms do
   In fact, the `:bind_quoted` option is recommended every time
   one desires to inject a value into the quote.
   """
-  defmacro quote(opts, block), do: error!([opts, block])
+  defmacro quote(opts, block)
 
   @doc """
   Unquotes the given expression from inside a macro.
@@ -1222,9 +1194,7 @@ defmodule Kernel.SpecialForms do
   would be:
 
       value = 13
-      quote do
-        sum(1, value, 3)
-      end
+      quote do: sum(1, value, 3)
 
   Which would then return:
 
@@ -1232,29 +1202,25 @@ defmodule Kernel.SpecialForms do
 
   Which is not the expected result. For this, we use unquote:
 
-      iex> value = 13
-      iex> quote do
-      ...>   sum(1, unquote(value), 3)
-      ...> end
-      {:sum, [], [1, 13, 3]}
+      value = 13
+      quote do: sum(1, unquote(value), 3)
+      #=> {:sum, [], [1, 13, 3]}
 
   """
-  defmacro unquote(:unquote)(expr), do: error!([expr])
+  defmacro unquote(:unquote)(expr)
 
   @doc """
   Unquotes the given list expanding its arguments. Similar
-  to `unquote/1`.
+  to unquote.
 
   ## Examples
 
-      iex> values = [2, 3, 4]
-      iex> quote do
-      ...>   sum(1, unquote_splicing(values), 5)
-      ...> end
-      {:sum, [], [1, 2, 3, 4, 5]}
+      values = [2, 3, 4]
+      quote do: sum(1, unquote_splicing(values), 5)
+      #=> {:sum, [], [1, 2, 3, 4, 5]}
 
   """
-  defmacro unquote(:unquote_splicing)(expr), do: error!([expr])
+  defmacro unquote(:unquote_splicing)(expr)
 
   @doc ~S"""
   Comprehensions allow you to quickly build a data structure from
@@ -1283,10 +1249,9 @@ defmodule Kernel.SpecialForms do
       [2, 4, 6]
 
   Note generators can also be used to filter as it removes any value
-  that doesn't match the pattern on the left side of `<-`:
+  that doesn't match the left side of `<-`:
 
-      iex> users = [user: "john", admin: "meg", guest: "barbara"]
-      iex> for {type, name} when type != :guest <- users do
+      iex> for {:user, name} <- [user: "john", admin: "james", user: "meg"] do
       ...>   String.upcase(name)
       ...> end
       ["JOHN", "MEG"]
@@ -1323,7 +1288,7 @@ defmodule Kernel.SpecialForms do
       end
 
   """
-  defmacro for(args), do: error!([args])
+  defmacro for(args)
 
   @doc """
   Used to combine matching clauses.
@@ -1337,7 +1302,7 @@ defmodule Kernel.SpecialForms do
       {:ok, 150}
 
   If all clauses match, the `do` block is executed, returning its result.
-  Otherwise the chain is aborted and the non-matched value is returned:
+  Otherwise the chain is aborted and a non-matched value is returned:
 
       iex> opts = %{width: 10}
       iex> with {:ok, width} <- Map.fetch(opts, :width),
@@ -1345,15 +1310,8 @@ defmodule Kernel.SpecialForms do
       ...>   do: {:ok, width * height}
       :error
 
-  Guards can be used in patterns as well:
-
-      iex> users = %{"melany" => "guest", "bob" => :admin}
-      iex> with {:ok, role} when not is_binary(role) <- Map.fetch(users, "bob"),
-      ...>   do: {:ok, to_string(role)}
-      {:ok, "admin"}
-
-  As in `for/1`, variables bound inside `with/1` won't leak;
-  "bare expressions" may also be inserted between the clauses:
+  Similarly to `for`/1, variables bound inside `with/1` won't leak,
+  and also it allows "bare expressions":
 
       iex> width = nil
       iex> opts = %{width: 10, height: 15}
@@ -1365,23 +1323,8 @@ defmodule Kernel.SpecialForms do
       iex> width
       nil
 
-  An `else` option can be given to modify what is being returned from
-  `with` in the case of a failed match:
-
-      iex> opts = %{width: 10}
-      iex> with {:ok, width} <- Map.fetch(opts, :width),
-      ...>      {:ok, height} <- Map.fetch(opts, :height) do
-      ...>   {:ok, width * height}
-      ...> else
-      ...>   :error ->
-      ...>     {:error, :wrong_data}
-      ...> end
-      {:error, :wrong_data}
-
-  If there is no matching `else` condition, then a `WithClauseError` exception is raised.
-
   """
-  defmacro with(args), do: error!([args])
+  defmacro with(args)
 
   @doc """
   Defines an anonymous function.
@@ -1393,7 +1336,7 @@ defmodule Kernel.SpecialForms do
       3
 
   """
-  defmacro unquote(:fn)(clauses), do: error!([clauses])
+  defmacro unquote(:fn)(clauses)
 
   @doc """
   Internal special form for block expressions.
@@ -1402,15 +1345,11 @@ defmodule Kernel.SpecialForms do
   of expressions in Elixir. This special form is private
   and should not be invoked directly:
 
-      iex> quote do
-      ...>   1
-      ...>   2
-      ...>   3
-      ...> end
+      iex> quote do: (1; 2; 3)
       {:__block__, [], [1, 2, 3]}
 
   """
-  defmacro __block__(args), do: error!([args])
+  defmacro __block__(args)
 
   @doc """
   Captures or creates an anonymous function.
@@ -1464,39 +1403,35 @@ defmodule Kernel.SpecialForms do
       iex> fun.(1, 2)
       {1, 2}
 
-      iex> fun = &[&1 | &2]
+      iex> fun = &[&1|&2]
       iex> fun.(1, 2)
-      [1 | 2]
+      [1|2]
 
   The only restrictions when creating anonymous functions is that at
   least one placeholder must be present, i.e. it must contain at least
-  `&1`, and that block expressions are not supported:
+  `&1`:
 
-      # No placeholder, fails to compile.
-      &(:foo)
+      # No placeholder fails to compile
+      &var
 
-      # Block expression, fails to compile.
-      &(&1; &2)
+      # Block expressions are also not supported
+      &(foo(&1, &2); &3 + &4)
 
   """
-  defmacro unquote(:&)(expr), do: error!([expr])
+  defmacro unquote(:&)(expr)
 
   @doc """
   Internal special form to hold aliases information.
 
   It is usually compiled to an atom:
 
-      iex> quote do
-      ...>   Foo.Bar
-      ...> end
+      iex> quote do: Foo.Bar
       {:__aliases__, [alias: false], [:Foo, :Bar]}
 
   Elixir represents `Foo.Bar` as `__aliases__` so calls can be
   unambiguously identified by the operator `:.`. For example:
 
-      iex> quote do
-      ...>   Foo.bar
-      ...> end
+      iex> quote do: Foo.bar
       {{:., [], [{:__aliases__, [alias: false], [:Foo]}, :bar]}, [], []}
 
   Whenever an expression iterator sees a `:.` as the tuple key,
@@ -1510,19 +1445,19 @@ defmodule Kernel.SpecialForms do
 
     2. The tail elements of aliases are guaranteed to always be atoms.
 
-    3. When the head element of aliases is the atom `:Elixir`, no expansion happens.
+    3. When the head element of aliases is the atom `:Elixir`, no expansion happen.
 
   """
-  defmacro __aliases__(args), do: error!([args])
+  defmacro __aliases__(args)
 
   @doc """
-  Calls the overridden function when overriding it with `Kernel.defoverridable/1`.
+  Calls the overriden function when overriding it with `Kernel.defoverridable/1`.
 
   See `Kernel.defoverridable/1` for more information and documentation.
   """
-  defmacro super(args), do: error!([args])
+  defmacro super(args)
 
-  @doc ~S"""
+  @doc """
   Matches the given expression against the given clauses.
 
   ## Examples
@@ -1536,21 +1471,7 @@ defmodule Kernel.SpecialForms do
 
   In the example above, we match `thing` against each clause "head"
   and execute the clause "body" corresponding to the first clause
-  that matches.
-
-  If no clause matches, an error is raised.
-  For this reason, it may be necessary to add a final catch-all clause (like `_`)
-  which will always match.
-
-      x = 10
-
-      case x do
-        0 ->
-          "This clause won't match"
-        _ ->
-          "This clause would match any value (x = #{x})"
-      end
-      #=> "This clause would match any value (x = 10)"
+  that matches. If no clause matches, an error is raised.
 
   ## Variables handling
 
@@ -1580,34 +1501,14 @@ defmodule Kernel.SpecialForms do
   the value of `lucky?`. In case `value` has no previous value before
   case, clauses that do not explicitly bind a value have the variable
   bound to `nil`.
-
-  If you want to pattern match against an existing variable,
-  you need to use the `^/1` operator:
-
-      x = 1
-
-      case 10 do
-        ^x -> "Won't match"
-        _  -> "Will match"
-      end
-      #=> "Will match"
-
   """
-  defmacro case(condition, clauses), do: error!([condition, clauses])
+  defmacro case(condition, clauses)
 
   @doc """
   Evaluates the expression corresponding to the first clause that
   evaluates to a truthy value.
 
-      cond do
-        hd([1, 2, 3]) ->
-          "1 is considered as true"
-      end
-      #=> "1 is considered as true"
-
   Raises an error if all conditions evaluate to `nil` or `false`.
-  For this reason, it may be necessary to add a final always-truthy condition
-  (anything non-`false` and non-`nil`), which will always match.
 
   ## Examples
 
@@ -1619,13 +1520,12 @@ defmodule Kernel.SpecialForms do
         true ->
           "This will"
       end
-      #=> "This will"
 
   """
-  defmacro cond(clauses), do: error!([clauses])
+  defmacro cond(clauses)
 
   @doc ~S"""
-  Evaluates the given expressions and handles any error, exit
+  Evaluates the given expressions and handle any error, exit
   or throw that may have happened.
 
   ## Examples
@@ -1650,7 +1550,7 @@ defmodule Kernel.SpecialForms do
   be used to control flow based on the result of the expression.
   Catch, rescue and else clauses work based on pattern matching.
 
-  Note that calls inside `try/1` are not tail recursive since the VM
+  Note that calls inside `try` are not tail recursive since the VM
   needs to keep the stacktrace in case an exception happens.
 
   ## Rescue clauses
@@ -1706,7 +1606,7 @@ defmodule Kernel.SpecialForms do
         ErlangError -> :ok
       end
 
-  In fact, `ErlangError` can be used to rescue any error that is
+  In fact, ErlangError can be used to rescue any error that is
   not an Elixir error proper. For example, it can be used to rescue
   the earlier `:badarg` error too, prior to transformation:
 
@@ -1736,23 +1636,6 @@ defmodule Kernel.SpecialForms do
   catch values also support `:error`, as in Erlang, although it is
   commonly avoided in favor of raise/rescue control mechanisms.
 
-  ## After clauses
-
-  An `after` clause allows you to define cleanup logic that will be invoked both
-  when the tried block of code succeeds and also when an error is raised. Note
-  that the process will exit as usually when receiving an exit signal that causes
-  it to exit abruptly and so the `after` clause is not guaranteed to be executed.
-  Luckily, most resources in Elixir (such as open files, ETS tables, ports, sockets,
-  etc.) are linked to or monitor the owning process and will automatically clean
-  themselves up if that process exits.
-
-      File.write!("tmp/story.txt", "Hello, World")
-      try do
-        do_something_with("tmp/story.txt")
-      after
-        File.rm("tmp/story.txt")
-      end
-
   ## Else clauses
 
   Else clauses allow the result of the expression to be pattern
@@ -1771,8 +1654,8 @@ defmodule Kernel.SpecialForms do
           :large
       end
 
-  If an else clause is not present and no exceptions are raised,
-  the result of the expression will be returned:
+  If an else clause is not present the result of the expression will
+  be return, if no exceptions are raised:
 
       x = 1
       ^x =
@@ -1860,7 +1743,7 @@ defmodule Kernel.SpecialForms do
         end
 
   """
-  defmacro try(args), do: error!([args])
+  defmacro try(args)
 
   @doc """
   Checks if there is a message matching the given clauses
@@ -1880,8 +1763,8 @@ defmodule Kernel.SpecialForms do
           IO.puts :stderr, "Unexpected message received"
       end
 
-  An optional `after` clause can be given in case the message was not
-  received after the specified timeout period:
+  An optional after clause can be given in case the message was not
+  received after the specified period of time:
 
       receive do
         {:selector, i, value} when is_integer(i) ->
@@ -1896,19 +1779,18 @@ defmodule Kernel.SpecialForms do
       end
 
   The `after` clause can be specified even if there are no match clauses.
-  The timeout value given to `after` can be a variable; two special
-  values are allowed:
+  There are two special cases for the timeout value given to `after`
 
     * `:infinity` - the process should wait indefinitely for a matching
       message, this is the same as not using a timeout
 
-    * `0` - if there is no matching message in the mailbox, the timeout
+    * 0 - if there is no matching message in the mailbox, the timeout
       will occur immediately
 
   ## Variables handling
 
-  The `receive/1` special form handles variables exactly as the `case/2`
+  The `receive` special form handles variables exactly as the `case`
   special macro. For more information, check the docs for `case/2`.
   """
-  defmacro receive(args), do: error!([args])
+  defmacro receive(args)
 end

lib/elixir/lib/kernel/typespec.ex

@@ -92,12 +92,6 @@ defmodule Kernel.Typespec do
     end
   end
 
-  defmacro defoptional_callbacks(callbacks) do
-    quote do
-      Module.store_typespec(__ENV__.module, :optional_callbacks, {__ENV__.line, unquote(callbacks)})
-    end
-  end
-
   @doc """
   Defines a `type`, `typep` or `opaque` by receiving a typespec expression.
   """
@@ -202,7 +196,7 @@ 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
 
@@ -211,11 +205,10 @@ defmodule Kernel.Typespec do
     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
@@ -414,11 +407,7 @@ defmodule Kernel.Typespec do
 
   defp elixir_builtin_type?(:as_boolean, 1), do: true
   defp elixir_builtin_type?(:struct, 0), do: true
-  defp elixir_builtin_type?(:charlist, 0), do: true
-  # TODO: Deprecate char_list type by v1.5
   defp elixir_builtin_type?(:char_list, 0), do: true
-  defp elixir_builtin_type?(:keyword, 0), do: true
-  defp elixir_builtin_type?(:keyword, 1), do: true
   defp elixir_builtin_type?(_, _), do: false
 
   @doc false
@@ -430,9 +419,32 @@ defmodule Kernel.Typespec 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
@@ -445,31 +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(:macrocallback, meta, name, args, return, guard, caller),
-    do: translate_spec(:callback, meta, :"MACRO-#{name}", [quote(do: env :: Macro.Env.t) | args], 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]} ->
@@ -497,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
 
@@ -573,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} ->
-        {:..., [line: line], nil}
-      {: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__)
@@ -595,13 +580,13 @@ defmodule Kernel.Typespec do
 
   defp typespec_to_ast({:type, line, :binary, [arg1, arg2]}) do
     [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_ast(arg)
-    case {typespec_to_ast(arg1), typespec_to_ast(arg2)} do
-      {arg1, 0} ->
+    cond do
+      arg2 == 0 ->
         quote line: line, do: <<_ :: unquote(arg1)>>
-      {0, arg2} ->
+      arg1 == 0 ->
         quote line: line, do: <<_ :: _ * unquote(arg2)>>
-      {arg1, arg2} ->
-        quote line: line, do: <<_ :: unquote(arg1), _ :: _ * unquote(arg2)>>
+      true ->
+        quote line: line, do: <<_ :: unquote(arg1) * unquote(arg2)>>
     end
   end
 
@@ -645,10 +630,8 @@ defmodule Kernel.Typespec do
   end
 
   # Special shortcut(s)
-  # TODO: Deprecate char_list type by v1.5
-  defp typespec_to_ast({:remote_type, line, [{:atom, _, :elixir}, {:atom, _, type}, []]})
-      when type in [:charlist, :char_list] do
-    typespec_to_ast({:type, line, :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
@@ -659,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)]}
@@ -728,16 +707,16 @@ defmodule Kernel.Typespec do
     {:type, line(meta), :binary, [{:integer, line(meta), 0}, {:integer, line(unit_meta), unit}]}
   end
 
+  defp typespec({:<<>>, meta, [{:::, shared_meta, [{:_, _, ctx}, {:*, _, [size, unit]}]}]}, _, _)
+      when is_atom(ctx) and is_integer(unit) and is_integer(size) do
+    {:type, line(meta), :binary, [{:integer, line(shared_meta), size}, {:integer, line(shared_meta), unit}]}
+  end
+
   defp typespec({:<<>>, meta, [{:::, size_meta, [{:_, _, ctx}, size]}]}, _, _)
       when is_atom(ctx) and is_integer(size) do
     {:type, line(meta), :binary, [{:integer, line(size_meta), size}, {:integer, line(meta), 0}]}
   end
 
-  defp typespec({:<<>>, meta, [{:::, size_meta, [{:_, _, ctx1}, size]}, {:::, unit_meta, [{:_, _, ctx2}, {:*, _, [{:_, _, ctx3}, unit]}]}]}, _, _)
-      when is_atom(ctx1) and is_atom(ctx2) and is_atom(ctx3) and is_integer(size) and is_integer(unit) do
-    {:type, line(meta), :binary, [{:integer, line(size_meta), size}, {:integer, line(unit_meta), unit}]}
-  end
-
   ## Handle maps and structs
   defp typespec({:map, meta, args}, _vars, _caller) when args == [] or is_atom(args) do
     {:type, line(meta), :map, :any}
@@ -746,25 +725,11 @@ defmodule Kernel.Typespec do
   defp typespec({:%{}, meta, fields} = map, vars, caller) do
     fields =
       :lists.map(fn
-        :... ->
-          {:type, line(meta), :map_field_assoc, :any}
-        {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.5
-          # :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)
@@ -822,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
@@ -854,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
@@ -904,14 +869,13 @@ defmodule Kernel.Typespec do
   # Handle local calls
   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 " <>
-      "charlist() type, for strings, String.t()\n#{Exception.format_stacktrace(Macro.Env.stacktrace(caller))}"
+      "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), type, arguments}
   end
 
-  # TODO: Deprecate char_list type by v1.5
-  defp typespec({type, _meta, []}, vars, caller) when type in [:charlist, :char_list] do
-    typespec((quote do: :elixir.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
@@ -922,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}
@@ -964,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)
@@ -986,7 +946,7 @@ defmodule Kernel.Typespec do
     {: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
@@ -1014,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

@@ -8,12 +8,12 @@ defmodule Kernel.Utils do
 
   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)]
 
-  def defdelegate(fun, opts) do
+  def defdelegate(fun, opts, env) do
     append_first = Keyword.get(opts, :append_first, false)
 
     {name, args} =
@@ -22,44 +22,32 @@ defmodule Kernel.Utils do
         _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
       end
 
-    as_args_list = normalize_args(args)
-    as = Keyword.get(opts, :as, name)
-    :lists.map(fn as_args ->
-      formal_args = make_formal_args(as_args)
-      as_args = case append_first do
-        true  -> tl(as_args) ++ [hd(as_args)]
-        false -> as_args
+    :ok = check_defdelegate_args(args, env)
+
+    as_args =
+      case append_first and args != [] do
+        true  -> tl(args) ++ [hd(args)]
+        false -> args
       end
-      {name, formal_args, as, as_args}
-    end, as_args_list)
+
+    as = Keyword.get(opts, :as, name)
+    {name, args, as, as_args}
   end
 
-  defp make_formal_args(args) do
-    fun = &match?({name, _, mod} when is_atom(name) and is_atom(mod), &1)
-    :lists.filter(fun, args)
-  end
-
-  defp normalize_args(raw_args) do
-    :lists.foldr(fn
-      ({:\\, _, [arg, default_arg]}, [as_args | _] = as_args_list) ->
-        new_as_args = [default_arg | as_args]
-        [new_as_args | add_arg(as_args_list, arg)]
-      (arg, as_args_list) ->
-        add_arg(as_args_list, arg)
-    end, [[]], raw_args)
-  end
-
-  defp add_arg(as_args_list, {name, _, mod} = arg) when is_atom(name) and is_atom(mod),
-    do: :lists.map(&([arg | &1]), as_args_list)
-  defp add_arg(_, code) do
-    raise ArgumentError,
-      "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(code)}"
+  # 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
 
   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
@@ -80,8 +68,6 @@ defmodule Kernel.Utils do
         raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
     end, fields)
 
-    {:maps.put(:__struct__, module, :maps.from_list(fields)),
-     List.wrap(Module.get_attribute(module, :enforce_keys)),
-     Module.get_attribute(module, :derive)}
+    :maps.put(:__struct__, module, :maps.from_list(fields))
   end
 end

lib/elixir/lib/keyword.ex

@@ -2,12 +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.
 
   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.
 
@@ -71,7 +71,7 @@ defmodule Keyword do
       []
 
   """
-  @spec new :: []
+  @spec new :: t
   def new, do: []
 
   @doc """
@@ -104,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]
 
   """
@@ -191,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
 
@@ -212,40 +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)}
-    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)}
-    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`.
 
@@ -254,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!"]}
@@ -264,28 +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)}
-    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
@@ -350,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)
@@ -472,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 """
@@ -500,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
 
@@ -520,7 +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]
+      false -> [{key, value}|keywords]
     end
   end
 
@@ -602,13 +581,13 @@ defmodule Keyword do
     do_merge(keywords2, [], keywords1, keywords1, fun)
   end
 
-  defp do_merge([{k, v2} | t], acc, rest, original, fun) do
+  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],
+        do_merge(t, [{k, fun.(k, v1, v2)}|acc],
                  delete(rest, k), :lists.keydelete(k, 1, original), fun)
       false ->
-        do_merge(t, [{k, v2} | acc], rest, original, fun)
+        do_merge(t, [{k, v2}|acc], rest, original, fun)
     end
   end
 
@@ -656,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
@@ -689,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
@@ -707,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.
 
@@ -722,8 +701,8 @@ defmodule Keyword do
   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
 
@@ -866,10 +845,10 @@ defmodule Keyword do
     keyword
   end
 
+  # TODO: Deprecate by 1.3
+  # TODO: Remove by 1.4
   @doc false
-  # TODO: Remove on 2.0
   def size(keyword) do
-    IO.warn "Keyword.size/1 is deprecated, please use Kernel.length/1"
     length(keyword)
   end
 end

lib/elixir/lib/list.ex

@@ -14,23 +14,23 @@ defmodule List do
   of receiving the subject (in this case, a list) as the
   first argument.
 
-  ## Charlists
+  ## Char lists
 
   If a list is made of non-negative integers, it can also
-  be called as a charlist. Elixir uses single quotes to
-  define charlists:
+  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`:
 
@@ -117,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
 
   """
@@ -135,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
 
   """
@@ -160,8 +160,8 @@ defmodule List do
 
   """
   @spec first([elem]) :: nil | elem when elem: var
-  def first([]),      do: nil
-  def first([h | _]), do: h
+  def first([]),    do: nil
+  def first([h|_]), do: h
 
   @doc """
   Returns the last element in `list` or `nil` if `list` is empty.
@@ -179,9 +179,9 @@ defmodule List do
 
   """
   @spec last([elem]) :: nil | elem when elem: var
-  def last([]),      do: nil
-  def last([h]),     do: h
-  def last([_ | t]), do: last(t)
+  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
@@ -492,9 +492,9 @@ defmodule List do
   end
 
   @doc """
-  Converts a charlist to an atom.
+  Converts a char list 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.
@@ -505,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.
@@ -529,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.
 
@@ -545,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.
 
@@ -561,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.
 
@@ -577,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 """
@@ -618,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

lib/elixir/lib/list/chars.ex

@@ -3,54 +3,54 @@ defprotocol List.Chars do
   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` which does the conversion.
+  `to_char_list` which does the conversion.
 
-  The `to_charlist` function automatically imported
+  The `to_char_list` function automatically imported
   by Kernel invokes this protocol.
   """
 
-  def to_charlist(term)
-
-  # TODO: Deprecate by v1.5
-  @doc false
-  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,58 +1,21 @@
 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)"
@@ -101,30 +64,7 @@ defmodule Macro do
   @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
@@ -136,7 +76,7 @@ defmodule Macro do
   end
 
   defp unpipe(other, acc) do
-    [{other, 0} | acc]
+    [{other, 0}|acc]
   end
 
   @doc """
@@ -153,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
     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
@@ -191,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.
 
@@ -249,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}
@@ -258,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
 
@@ -279,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
 
@@ -287,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.
   """
@@ -340,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
 
   """
@@ -376,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
@@ -400,24 +315,8 @@ defmodule Macro do
   @doc """
   Validates the given expressions are valid quoted expressions.
 
-  Checks the `type:Macro.t` 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
@@ -455,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
@@ -500,15 +398,13 @@ 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` function returns `false`. The char is
-  not escaped and `\` is kept in the charlist.
+  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
 
@@ -553,7 +449,7 @@ defmodule Macro do
 
   ## 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)"
 
   """
@@ -638,18 +534,17 @@ 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
@@ -717,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
@@ -766,13 +661,13 @@ defmodule Macro do
   # Block keywords
   @kw_keywords [:do, :catch, :rescue, :after, :else]
 
-  defp kw_blocks?([{:do, _} | _] = kw) do
+  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
@@ -822,8 +717,6 @@ 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({:., _, [arg]}, fun),
     do: module_to_string(arg, fun) <> "."
   defp call_to_string({:., _, [left, right]}, fun),
@@ -841,12 +734,9 @@ defmodule Macro do
     {list, last} = :elixir_utils.split_last(args)
 
     if last != [] and Keyword.keyword?(last) do
-      prefix =
-        case list do
-          [] -> ""
-          _  -> Enum.map_join(list, ", ", &to_string(&1, fun)) <> ", "
-        end
-      prefix <> kw_list_to_string(last, fun)
+      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
@@ -866,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  "
@@ -976,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
@@ -1016,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
@@ -1050,6 +940,14 @@ defmodule Macro do
     end
   end
 
+  # 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}
@@ -1098,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}
@@ -1119,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}
@@ -1155,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"
@@ -1180,9 +1073,6 @@ 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)
@@ -1220,11 +1110,6 @@ 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"
@@ -1249,9 +1134,6 @@ defmodule Macro do
   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: <<>>
 

lib/elixir/lib/macro/env.ex

@@ -29,8 +29,8 @@ 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
@@ -94,10 +94,6 @@ defmodule Macro.Env do
       lexical_tracker: nil}
   end
 
-  def __struct__(kv) do
-    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
-  end
-
   @doc """
   Returns a keyword list containing the file and line
   information as keys.

lib/elixir/lib/map.ex

@@ -13,7 +13,7 @@ defmodule Map do
   @compile {:inline, fetch: 2, put: 3, delete: 2, has_key?: 2}
 
   @doc """
-  Returns all keys from `map`.
+  Returns all keys from the map.
 
   ## Examples
 
@@ -25,7 +25,7 @@ defmodule Map do
   defdelegate keys(map), to: :maps
 
   @doc """
-  Returns all values from `map`.
+  Returns all values from the map.
 
   ## Examples
 
@@ -37,7 +37,7 @@ defmodule Map do
   defdelegate values(map), to: :maps
 
   @doc """
-  Converts `map` to a list.
+  Converts the map to a list.
 
   ## Examples
 
@@ -63,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.
 
@@ -76,21 +76,14 @@ defmodule Map do
 
   """
   @spec new(Enum.t) :: map
-  def new(enumerable)
-  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
+  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 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
 
@@ -100,18 +93,11 @@ defmodule Map do
   """
   @spec new(Enum.t, (term -> {key, value})) :: map
   def new(enumerable, transform) do
-    enumerable
-    |> Enum.to_list
-    |> do_new_transform(transform, [])
-  end
-
-  defp do_new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new_transform([item | rest], fun, acc) do
-    do_new_transform(rest, fun, [fun.(item) | acc])
+    fun = fn el, acc ->
+      {k, v} = transform.(el)
+      put(acc, k, v)
+    end
+    Enum.reduce(enumerable, %{}, fun)
   end
 
   @doc """
@@ -223,20 +209,14 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec take(map, Enumerable.t) :: map
+  @spec take(map, [key]) :: map
   def take(map, keys) do
-    keys
-    |> Enum.to_list
-    |> do_take(map, [])
-  end
-
-  defp do_take([], _map, acc), do: :maps.from_list(acc)
-  defp do_take([key | rest], map, acc) do
-    acc = case fetch(map, key) do
-      {:ok, value} -> [{key, value} | acc]
-      :error -> acc
-    end
-    do_take(rest, map, acc)
+    Enum.reduce(keys, new, fn key, acc ->
+      case fetch(map, key) do
+        {:ok, value} -> put(acc, key, value)
+        :error -> acc
+      end
+    end)
   end
 
   @doc """
@@ -312,9 +292,9 @@ defmodule Map do
   end
 
   @doc """
-  Deletes the entries 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
 
@@ -332,11 +312,6 @@ defmodule Map do
 
   All keys in `map2` will be added to `map1`, overriding any existing one.
 
-  If you have a struct and you would like to merge a set of keys into the
-  struct, do not use this function, as it would merge all keys on the right
-  side into the struct, even if the key is not part of the struct. Instead,
-  use `Kernel.struct/2`.
-
   ## Examples
 
       iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
@@ -391,7 +366,7 @@ defmodule Map do
   end
 
   @doc """
-  Returns and removes the value associated with `key` in `map`.
+  Returns and removes all values associated with `key` in the `map`.
 
   ## Examples
 
@@ -405,14 +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}
+    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`.
+  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.
@@ -439,7 +414,7 @@ defmodule Map do
   end
 
   @doc """
-  Drops the given `keys` from `map`.
+  Drops the given keys from the map.
 
   ## Examples
 
@@ -447,25 +422,18 @@ defmodule Map do
       %{a: 1, c: 3}
 
   """
-  @spec drop(map, Enumerable.t) :: map
+  @spec drop(map, [key]) :: map
   def drop(map, keys) do
-    keys
-    |> Enum.to_list
-    |> drop_list(map)
-  end
-
-  defp drop_list([], acc), do: acc
-  defp drop_list([key | rest], acc) do
-    drop_list(rest, Map.delete(acc, key))
+    Enum.reduce(keys, map, &delete(&2, &1))
   end
 
   @doc """
-  Takes all entries corresponding to the given `keys` 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
 
@@ -473,23 +441,16 @@ defmodule Map do
       {%{a: 1, c: 3}, %{b: 2}}
 
   """
-  @spec split(map, Enumerable.t) :: {map, map}
+  @spec split(map, [key]) :: {map, map}
   def split(map, keys) do
-    keys
-    |> Enum.to_list
-    |> do_split([], map)
-  end
-
-  defp do_split([], inc, exc) do
-    {:maps.from_list(inc), exc}
-  end
-  defp do_split([key | rest], inc, exc) do
-    case fetch(exc, key) do
-      {:ok, value} ->
-        do_split(rest, [{key, value} | inc], delete(exc, key))
-      :error ->
-        do_split(rest, inc, exc)
-    end
+    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 """
@@ -522,14 +483,12 @@ defmodule Map 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 `map` 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 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
 
@@ -543,25 +502,16 @@ 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
+  @spec get_and_update(map, key, (value -> {get, value})) :: {get, map} when get: term
   def get_and_update(%{} = map, key, fun) do
-    current =
-      case :maps.find(key, map) do
-        {:ok, value} -> value
-        :error -> nil
-      end
-
-    case fun.(current) do
-      {get, update} -> {get, :maps.put(key, update, map)}
-      :pop          -> {current, :maps.remove(key, map)}
+    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})
@@ -570,7 +520,7 @@ defmodule Map do
   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`.
 
@@ -579,7 +529,7 @@ defmodule Map do
 
   ## 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!"}}
@@ -589,20 +539,13 @@ defmodule Map do
       ...> end)
       ** (KeyError) key :b not found
 
-      iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, %{}}
-
   """
   @spec get_and_update!(map, key, (value -> {get, value})) :: {get, map} | no_return when get: term
   def get_and_update!(%{} = map, key, fun) do
     case :maps.find(key, map) do
       {:ok, value} ->
-        case fun.(value) do
-          {get, update} -> {get, :maps.put(key, update, map)}
-          :pop          -> {value, :maps.remove(key, map)}
-        end
+        {get, update} = fun.(value)
+        {get, :maps.put(key, update, map)}
       :error ->
         :erlang.error({:badkey, key})
     end
@@ -611,7 +554,7 @@ defmodule Map do
   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 struct.
@@ -655,10 +598,10 @@ defmodule Map do
   @spec equal?(map, map) :: boolean
   def equal?(%{} = map1, %{} = map2), do: map1 === map2
 
+  # TODO: Deprecate by 1.3
+  # TODO: Remove by 1.4
   @doc false
-  # TODO: Remove on 2.0
   def size(map) do
-    IO.warn "Map.size/1 is deprecated, please use Kernel.map_size/1"
     map_size(map)
   end
 end

lib/elixir/lib/map_set.ex

@@ -37,14 +37,8 @@ defmodule MapSet do
 
   """
   @spec new(Enum.t) :: t
-  def new(%__MODULE__{} = mapset), do: mapset
   def new(enumerable) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> do_new([])
-
-    %MapSet{map: map}
+    Enum.reduce(enumerable, %MapSet{}, &put(&2, &1))
   end
 
   @doc """
@@ -58,30 +52,7 @@ defmodule MapSet do
   """
   @spec new(Enum.t, (term -> term)) :: t
   def new(enumerable, transform) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> do_new_transform(transform, [])
-
-    %MapSet{map: map}
-  end
-
-  defp do_new([], acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new([item | rest], acc) do
-    do_new(rest, [{item, true} | acc])
-  end
-
-  defp do_new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-  defp do_new_transform([item | rest], fun, acc) do
-    do_new_transform(rest, fun, [{fun.(item), true} | acc])
+    Enum.reduce(enumerable, %MapSet{}, &put(&2, transform.(&1)))
   end
 
   @doc """
@@ -99,8 +70,8 @@ defmodule MapSet do
 
   """
   @spec delete(t, value) :: t
-  def delete(%MapSet{map: map} = set, value) do
-    %{set | map: Map.delete(map, value)}
+  def delete(%MapSet{map: map} = set, term) do
+    %{set | map: Map.delete(map, term)}
   end
 
   @doc """
@@ -113,34 +84,11 @@ defmodule MapSet do
 
   """
   @spec difference(t, t) :: t
-  # If the first set is less than twice the size of the second map,
-  # it is fastest to re-accumulate items in the first set that are not
-  # present in the second set.
-  def difference(%MapSet{map: map1}, %MapSet{map: map2})
-  when map_size(map1) < map_size(map2) * 2 do
-    map = map1
-    |> Map.keys
-    |> filter_not_in(map2)
-
-    %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}, %MapSet{map: map2}) do
-    %MapSet{map: Map.drop(map1, Map.keys(map2))}
-  end
-
-  defp filter_not_in(keys, map2, acc \\ [])
-  defp filter_not_in([], _map2, acc), do: :maps.from_list(acc)
-  defp filter_not_in([key | rest], map2, acc) do
-    acc = if Map.has_key?(map2, key) do
-      acc
-    else
-      [{key, true} | acc]
-    end
-    filter_not_in(rest, map2, acc)
+    map = :maps.fold(fn value, _, acc ->
+      Map.delete(acc, value)
+    end, map1, map2)
+    %MapSet{map: map}
   end
 
   @doc """
@@ -156,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 """
@@ -205,9 +148,15 @@ defmodule MapSet do
   """
   @spec intersection(t, t) :: t
   def intersection(%MapSet{map: map1}, %MapSet{map: map2}) do
-    {map1, map2} = order_by_size(map1, map2)
-
-    %MapSet{map: Map.take(map2, Map.keys(map1))}
+    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 """
@@ -272,21 +221,18 @@ 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
-      |> do_subset?(map2)
-    else
-      false
-    end
-  end
-
-  defp do_subset?([], _), do: true
-  defp do_subset?([key | rest], map2) do
-    if Map.has_key?(map2, key) do
-      do_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 """
@@ -317,9 +263,6 @@ defmodule MapSet do
     %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(set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(set), acc, fun)
     def member?(set, val),     do: {:ok, MapSet.member?(set, val)}

lib/elixir/lib/module.ex

@@ -18,16 +18,53 @@ defmodule Module do
     * `@after_compile`
 
       A hook that will be invoked right after the current module is compiled.
-      Accepts a module or a tuple `{<module>, <function atom>}`.
-      See the "Compile callbacks" section below.
+
+      Accepts a module or a tuple `{<module>, <function atom>}`. The function
+      must take two arguments: the module environment and its bytecode.
+      When just a module is provided, the function is assumed to be
+      `__after_compile__/2`.
+
+      ### Example
+
+          defmodule M do
+            @after_compile __MODULE__
+
+            def __after_compile__(env, _bytecode) do
+              IO.inspect env
+            end
+          end
 
     * `@before_compile`
 
       A hook that will be invoked before the module is compiled.
-      Accepts a module or a tuple `{<module>, <function/macro atom>}`.
-      See the "Compile callbacks" section below.
 
-    * `@behaviour` (notice the British spelling)
+      Accepts a module or a tuple `{<module>, <function/macro atom>}`. The
+      function/macro must take one argument: the module environment. If it's a
+      macro, its returned value will be injected at the end of the module definition
+      before the compilation starts.
+
+      When just a module is provided, the function/macro is assumed to be
+      `__before_compile__/1`.
+
+      Note: unlike `@after_compile`, the callback function/macro must
+      be placed in a separate module (because when the callback is invoked,
+      the current module does not yet exist).
+
+      ### Example
+
+          defmodule A do
+            defmacro __before_compile__(_env) do
+              quote do
+                def hello, do: "world"
+              end
+            end
+          end
+
+          defmodule B do
+            @before_compile A
+          end
+
+    * `@behaviour`   (notice the British spelling)
 
       Behaviours can be referenced by modules to ensure they implement
       required specific function signatures defined by `@callback`.
@@ -58,27 +95,23 @@ defmodule Module do
       ### Example
 
           defmodule M do
-            @behaviour :gen_event
+            @behaviour gen_event
 
             # ...
           end
 
-    * `@callback`, `@macrocallback`, and `@optional_callbacks`
-
-      These attributes are used to define a behaviour (as shown in the
-      documentation for `@behaviour` above). `@callback` defines a function
-      callback, `@macrocallback` defines a macro callback, and
-      `@optional_callbacks` specifies which callbacks and macrocallbacks are
-      optional.
-
     * `@compile`
 
-      Defines options for module compilation. This is used to configure
-      both Elixir and Erlang compilers, as any other compilation pass
-      added by external tools.
+      Defines options for module compilation that are passed to the Erlang
+      compiler.
+
+      Accepts an atom, a tuple, or a list of atoms and tuples.
+
+      For the list of supported options, see Erlang's
+      [`:compile` module](http://www.erlang.org/doc/man/compile.html).
 
       Multiple uses of `@compile` will accumulate instead of overriding
-      previous ones. See the "Compile options" section below.
+      previous ones.
 
       ### Example
 
@@ -117,40 +150,6 @@ defmodule Module do
             end
           end
 
-    * `@dialyzer`
-
-      Defines warnings to request or suppress when using a version of
-      `:dialyzer` that supports module attributes.
-
-      Accepts an atom, a tuple, or a list of atoms and tuples.
-
-      For the list of supported warnings, see
-      [`:dialyzer` module](http://www.erlang.org/doc/man/dialyzer.html).
-
-      Multiple uses of `@dialyzer` will accumulate instead of overriding
-      previous ones.
-
-      ### Example
-
-          defmodule M do
-            @dialyzer {:nowarn_function, myfun: 1}
-
-            def myfun(arg) do
-              M.not_a_function(arg)
-            end
-          end
-
-    * `@external_resource`
-
-      Specifies an external resource to the current module.
-
-      Many times a module embeds information from an external file. This
-      attribute allows the module to annotate which external resources
-      have been used.
-
-      Tools like Mix may use this information to ensure the module is
-      recompiled in case any of the external resources change.
-
     * `@file`
 
       Changes the filename used in stacktraces for the function or macro that
@@ -184,13 +183,61 @@ defmodule Module do
             """
           end
 
+
     * `@on_definition`
 
       A hook that will be invoked when each function or macro in the current
       module is defined. Useful when annotating functions.
 
-      Accepts a module or a tuple `{<module>, <function atom>}`. See the
-      "Compile callbacks" section below.
+      Accepts a module or a tuple `{<module>, <function atom>}`. The function
+      must take 6 arguments:
+
+        - the module environment
+        - kind: `:def`, `:defp`, `:defmacro`, or `:defmacrop`
+        - function/macro name
+        - list of quoted arguments
+        - list of quoted guards
+        - quoted function body
+
+      Note the hook receives the quoted arguments and it is invoked before
+      the function is stored in the module. So `Module.defines?/2` will return
+      `false` for the first clause of every function.
+
+      If the function/macro being defined has multiple clauses, the hook will
+      be called for each clause.
+
+      Unlike other hooks, `@on_definition` will only invoke functions
+      and never macros. This is because the hook is invoked inside the context
+      of the function (and nested function definitions are not allowed in
+      Elixir).
+
+      When just a module is provided, the function is assumed to be
+      `__on_definition__/6`.
+
+      ### Example
+
+          defmodule H do
+            def on_def(_env, kind, name, args, guards, body) do
+              IO.puts "Defining #{kind} named #{name} with args:"
+              IO.inspect args
+              IO.puts "and guards"
+              IO.inspect guards
+              IO.puts "and body"
+              IO.puts Macro.to_string(body)
+            end
+          end
+
+          defmodule M do
+            @on_definition {H, :on_def}
+
+            def hello(arg) when is_binary(arg) or is_list(arg) do
+              "Hello" <> to_string(arg)
+            end
+
+            def hello(_) do
+              :ok
+            end
+          end
 
     * `@on_load`
 
@@ -228,17 +275,49 @@ defmodule Module do
             @vsn "1.0"
           end
 
-  The following attributes are part of typespecs and are also reserved by
-  Elixir:
+    * `@external_resource`
 
-    * `@type` - defines a type to be used in `@spec`
-    * `@typep` - defines a private type to be used in `@spec`
-    * `@opaque` - defines an opaque type to be used in `@spec`
-    * `@spec` - provides a specification for a function
-    * `@callback` - provides a specification for a behaviour callback
+      Specifies an external resource to the current module.
+
+      Many times a module embeds information from an external file. This
+      attribute allows the module to annotate which external resources
+      have been used.
+
+      Tools like Mix may use this information to ensure the module is
+      recompiled in case any of the external resources change.
+
+    * `@dialyzer`
+
+      Defines warnings to request or suppress when using a version of
+      `:dialyzer` that supports module attributes.
+
+      Accepts an atom, a tuple, or a list of atoms and tuples.
+
+      For the list of supported warnings, see
+      [`:dialyzer` module](http://www.erlang.org/doc/man/dialyzer.html).
+
+      Multiple uses of `@dialyzer` will accumulate instead of overriding
+      previous ones.
+
+      ### Example
+
+          defmodule M do
+            @dialyzer {:nowarn_function, myfun: 1}
+
+            def myfun(arg) do
+              M.not_a_function(arg)
+            end
+          end
+
+  The following attributes are part of typespecs and are also reserved by
+  Elixir (see `Kernel.Typespec` for more information about typespecs):
+
+    * `@type`          - defines a type to be used in `@spec`
+    * `@typep`         - defines a private type to be used in `@spec`
+    * `@opaque`        - defines an opaque type to be used in `@spec`
+    * `@spec`          - provides a specification for a function
+    * `@callback`      - provides a specification for a behaviour callback
     * `@macrocallback` - provides a specification for a macro behaviour callback
-    * `@optional_callbacks` - specifies which behaviour callbacks and macro
-      behaviour callbacks are optional
 
   In addition to the built-in attributes outlined above, custom attributes may
   also be added. A custom attribute is any valid identifier prefixed with an
@@ -251,136 +330,10 @@ defmodule Module do
   For more advanced options available when defining custom attributes, see
   `register_attribute/3`.
 
-  ## Compile callbacks
+  ## Runtime information about a module
 
-  There are three callbacks that are invoked when functions are defined,
-  as well as before and immediately after the module bytecode is generated.
-
-  ### `@after_compile`
-
-  A hook that will be invoked right after the current module is compiled.
-
-  Accepts a module or a tuple `{<module>, <function atom>}`. The function
-  must take two arguments: the module environment and its bytecode.
-  When just a module is provided, the function is assumed to be
-  `__after_compile__/2`.
-
-  #### Example
-
-      defmodule M do
-        @after_compile __MODULE__
-
-        def __after_compile__(env, _bytecode) do
-          IO.inspect env
-        end
-      end
-
-  ### `@before_compile`
-
-  A hook that will be invoked before the module is compiled.
-
-  Accepts a module or a tuple `{<module>, <function/macro atom>}`. The
-  function/macro must take one argument: the module environment. If it's a
-  macro, its returned value will be injected at the end of the module definition
-  before the compilation starts.
-
-  When just a module is provided, the function/macro is assumed to be
-  `__before_compile__/1`.
-
-  Note: unlike `@after_compile`, the callback function/macro must
-  be placed in a separate module (because when the callback is invoked,
-  the current module does not yet exist).
-
-  #### Example
-
-      defmodule A do
-        defmacro __before_compile__(_env) do
-          quote do
-            def hello, do: "world"
-          end
-        end
-      end
-
-      defmodule B do
-        @before_compile A
-      end
-
-  ### `@on_definition`
-
-  A hook that will be invoked when each function or macro in the current
-  module is defined. Useful when annotating functions.
-
-  Accepts a module or a tuple `{<module>, <function atom>}`. The function
-  must take 6 arguments:
-
-    - the module environment
-    - kind: `:def`, `:defp`, `:defmacro`, or `:defmacrop`
-    - function/macro name
-    - list of quoted arguments
-    - list of quoted guards
-    - quoted function body
-
-  Note the hook receives the quoted arguments and it is invoked before
-  the function is stored in the module. So `Module.defines?/2` will return
-  `false` for the first clause of every function.
-
-  If the function/macro being defined has multiple clauses, the hook will
-  be called for each clause.
-
-  Unlike other hooks, `@on_definition` will only invoke functions
-  and never macros. This is because the hook is invoked inside the context
-  of the function (and nested function definitions are not allowed in
-  Elixir).
-
-  When just a module is provided, the function is assumed to be
-  `__on_definition__/6`.
-
-  #### Example
-
-      defmodule H do
-        def on_def(_env, kind, name, args, guards, body) do
-          IO.puts "Defining #{kind} named #{name} with args:"
-          IO.inspect args
-          IO.puts "and guards"
-          IO.inspect guards
-          IO.puts "and body"
-          IO.puts Macro.to_string(body)
-        end
-      end
-
-      defmodule M do
-        @on_definition {H, :on_def}
-
-        def hello(arg) when is_binary(arg) or is_list(arg) do
-          "Hello" <> to_string(arg)
-        end
-
-        def hello(_) do
-          :ok
-        end
-      end
-
-  ## Compile options
-
-  The `@compile` attribute accepts diverse options that is used by both
-  Elixir and Erlang compilers. Some of the common use cases are documented
-  below:
-
-    * `@compile :debug_info` - includes `:debug_info` regardless of the
-      setting in `Code.compiler_options`
-
-    * `@compile {:debug_info, false} - disables `:debug_info` regardless
-      of the setting in `Code.compiler_options`
-
-    * `@compile {:inline, some_fun: 2, other_fun: 3}` - inlines the given
-      name/arity pairs
-
-    * `@compile {:autoload, false}` - disables automatic loading of
-      modules after compilation. Instead, the module will be loaded after
-      it is dispatched to
-
-  You can see a handful more options used by the Erlang compiler in
-  the documentation for the `:compile` module.
+  It is possible to query a module at runtime to find out which functions and
+  macros it defines, extract its docstrings, etc. See `__info__/1`.
   '''
 
   @doc """
@@ -498,10 +451,6 @@ defmodule Module do
     unless Keyword.has_key?(opts, :file) do
       raise ArgumentError, "expected :file to be given as option"
     end
-
-    next = :erlang.unique_integer()
-    line = Keyword.get(opts, :line, 0)
-    quoted = :elixir_quote.linify_with_context_counter(line, {module, next}, quoted)
     :elixir_module.compile(module, quoted, [], :elixir.env_for_eval(opts))
   end
 
@@ -544,7 +493,7 @@ defmodule Module do
   was already referenced.
 
   If the alias was not referenced yet, fails with `ArgumentError`.
-  It handles charlists, binaries and atoms.
+  It handles char lists, binaries and atoms.
 
   ## Examples
 
@@ -565,7 +514,7 @@ defmodule Module do
   already referenced.
 
   If the alias was not referenced yet, fails with `ArgumentError`.
-  It handles charlists, binaries and atoms.
+  It handles char lists, binaries and atoms.
 
   ## Examples
 
@@ -669,7 +618,7 @@ defmodule Module do
   defp simplify_signature(_, acc),                            do: autogenerated(acc, :arg)
 
   defp autogenerated(acc, key) do
-    {key, [key | acc]}
+    {key, [key|acc]}
   end
 
   defp expand_signature(key, {all_keys, acc}) when is_atom(key) do
@@ -709,8 +658,8 @@ defmodule Module do
 
   # Merge
 
-  defp merge_signatures([h1 | t1], [h2 | t2], i) do
-    [merge_signature(h1, h2, i) | merge_signatures(t1, t2, i + 1)]
+  defp merge_signatures([h1|t1], [h2|t2], i) do
+    [merge_signature(h1, h2, i)|merge_signatures(t1, t2, i + 1)]
   end
 
   defp merge_signatures([], [], _) do
@@ -752,7 +701,7 @@ defmodule Module do
   def defines?(module, tuple) when is_tuple(tuple) do
     assert_not_compiled!(:defines?, module)
     table = defs_table_for(module)
-    :ets.lookup(table, {:def, tuple}) != []
+    :ets.lookup(table, tuple) != []
   end
 
   @doc """
@@ -773,7 +722,7 @@ defmodule Module do
   def defines?(module, tuple, kind) do
     assert_not_compiled!(:defines?, module)
     table = defs_table_for(module)
-    case :ets.lookup(table, {:def, tuple}) do
+    case :ets.lookup(table, tuple) do
       [{_, ^kind, _, _, _, _, _}] -> true
       _ -> false
     end
@@ -793,7 +742,7 @@ defmodule Module do
   def definitions_in(module) do
     assert_not_compiled!(:definitions_in, module)
     table = defs_table_for(module)
-    :lists.concat :ets.match(table, {{:def, :'$1'}, :_, :_, :_, :_, :_, :_})
+    :lists.concat :ets.match(table, {:'$1', :_, :_, :_, :_, :_, :_})
   end
 
   @doc """
@@ -812,7 +761,7 @@ defmodule Module do
   def definitions_in(module, kind) do
     assert_not_compiled!(:definitions_in, module)
     table = defs_table_for(module)
-    :lists.concat :ets.match(table, {{:def, :'$1'}, kind, :_, :_, :_, :_, :_})
+    :lists.concat :ets.match(table, {:'$1', kind, :_, :_, :_, :_, :_})
   end
 
   @doc """
@@ -826,17 +775,18 @@ defmodule Module do
     assert_not_compiled!(:make_overridable, module)
 
     :lists.foreach(fn tuple ->
-      case :elixir_def.take_definition(module, tuple) do
+      case :elixir_def.lookup_definition(module, tuple) do
         false ->
           {name, arity} = tuple
           raise "cannot make function #{name}/#{arity} overridable because it was not defined"
         clause ->
-          neighbours =
-            if :elixir_compiler.get_opt(:internal) do
-              []
-            else
-              Module.LocalsTracker.yank(module, tuple)
-            end
+          :elixir_def.delete_definition(module, tuple)
+
+          neighbours = if :elixir_compiler.get_opt(:internal) do
+            []
+          else
+            Module.LocalsTracker.yank(module, tuple)
+          end
 
           old   = :elixir_def_overridable.overridable(module)
           count = case :maps.find(tuple, old) do
@@ -859,7 +809,7 @@ defmodule Module do
   @doc """
   Puts an Erlang attribute to the given module with the given
   key and value.
-
+  
   The semantics of putting the attribute depends
   if the attribute was registered or not via `register_attribute/3`.
 
@@ -885,7 +835,7 @@ defmodule Module do
     new =
       if :lists.member(key, acc) do
         case :ets.lookup(table, key) do
-          [{^key, old}] -> [value | old]
+          [{^key, old}] -> [value|old]
           [] -> [value]
         end
       else
@@ -985,12 +935,12 @@ defmodule Module do
 
     if Keyword.get(opts, :persist) do
       old = :ets.lookup_element(table, {:elixir, :persisted_attributes}, 2)
-      :ets.insert(table, {{:elixir, :persisted_attributes}, [new | old]})
+      :ets.insert(table, {{:elixir, :persisted_attributes}, [new|old]})
     end
 
     if Keyword.get(opts, :accumulate) do
       old = :ets.lookup_element(table, {:elixir, :acc_attributes}, 2)
-      :ets.insert(table, {{:elixir, :acc_attributes}, [new | old]})
+      :ets.insert(table, {{:elixir, :acc_attributes}, [new|old]})
     end
   end
 
@@ -999,8 +949,8 @@ defmodule Module do
 
   ## Examples
 
-      iex> Module.split Very.Long.Module.Name.And.Even.Longer
-      ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
+      Module.split Very.Long.Module.Name.And.Even.Longer
+      #=> ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
 
   """
   def split(module) when is_atom(module) do
@@ -1054,7 +1004,7 @@ defmodule Module do
 
     new =
       case :ets.lookup(table, key) do
-        [{^key, old}] -> [value | old]
+        [{^key, old}] -> [value|old]
         [] -> [value]
       end
 
@@ -1068,7 +1018,7 @@ defmodule Module do
 
     case :ets.lookup(table, key) do
       [{^key, val}] ->
-        val
+        postprocess_attribute(key, val)
       [] ->
         acc = :ets.lookup_element(table, {:elixir, :acc_attributes}, 2)
 
@@ -1076,8 +1026,8 @@ defmodule Module do
           :lists.member(key, acc) ->
             []
           is_list(stack) ->
-            IO.warn "undefined module attribute @#{key}, " <>
-                    "please remove access to @#{key} or explicitly set it before access", stack
+            :elixir_errors.warn warn_info(stack), "undefined module attribute @#{key}, " <>
+              "please remove access to @#{key} or explicitly set it before access"
             nil
           true ->
             nil
@@ -1085,15 +1035,17 @@ defmodule Module do
     end
   end
 
-  ## Helpers
-
-  defp preprocess_attribute(key, value) when key in [:moduledoc, :typedoc, :doc] do
-    unless match?({line, _} when is_integer(line), value) do
-      raise ArgumentError, "expected #{key} attribute given in the {line, doc} format, got: #{inspect(value)}"
-    end
-    value
+  defp warn_info([entry|_]) do
+    opts = elem(entry, tuple_size(entry) - 1)
+    Exception.format_file_line(Keyword.get(opts, :file), Keyword.get(opts, :line)) <> " "
   end
 
+  defp warn_info([]) do
+    ""
+  end
+
+  ## Helpers
+
   defp preprocess_attribute(:on_load, atom) when is_atom(atom) do
     {atom, 0}
   end
@@ -1115,15 +1067,20 @@ defmodule Module do
   defp preprocess_attribute(:on_definition, atom) when is_atom(atom),
     do: {atom, :__on_definition__}
 
-  defp preprocess_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback, :macrocallback, :optional_callbacks] do
-    raise ArgumentError, "attributes type, typep, export_type, opaque, callback, macrocallback, and optional_callbacks " <>
-      "must be set directly via the @ notation"
+  defp preprocess_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback, :macrocallback] do
+    raise ArgumentError, "attributes type, typep, export_type, opaque, callback and macrocallback " <>
+      "must be set via Kernel.Typespec"
   end
 
   defp preprocess_attribute(_key, value) do
     value
   end
 
+  defp postprocess_attribute(:doc, {_line, doc}), do: doc
+  defp postprocess_attribute(:typedoc, {_line, doc}), do: doc
+  defp postprocess_attribute(:moduledoc, {_line, doc}), do: doc
+  defp postprocess_attribute(_, value), do: value
+
   defp get_doc_info(table, env) do
     case :ets.take(table, :doc) do
       [doc: {_, _} = pair] -> pair
@@ -1149,7 +1106,8 @@ defmodule Module do
       when is_list(stack) and key in [:doc, :typedoc, :moduledoc] do
     case :ets.lookup(table, key) do
       [{_, {line, val}}] when val != false ->
-        IO.warn "redefining @#{key} attribute previously set at line #{line}", stack
+        :elixir_errors.warn warn_info(stack),
+                            "redefining @#{key} attribute previously set at line #{line}"
       _ ->
         false
     end

lib/elixir/lib/module/locals_tracker.ex

@@ -121,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})
@@ -174,9 +174,9 @@ defmodule Module.LocalsTracker do
     reduce_unreachable(private, [], :sets.from_list(unreachable))
   end
 
-  defp reduce_unreachable([{vertex, callers} | t], acc, unreachable) do
+  defp reduce_unreachable([{vertex, callers}|t], acc, unreachable) do
     if :sets.is_subset(callers, unreachable) do
-      reduce_unreachable(t, [{vertex, callers} | acc], unreachable)
+      reduce_unreachable(t, [{vertex, callers}|acc], unreachable)
     else
       reduce_unreachable(acc ++ t, [], :sets.del_element(vertex, unreachable))
     end
@@ -195,7 +195,7 @@ defmodule Module.LocalsTracker do
     if :lists.member(tuple, reachable) do
       acc
     else
-      [{:unused_def, tuple, kind} | acc]
+      [{:unused_def, tuple, kind}|acc]
     end
   end
 
@@ -207,12 +207,12 @@ defmodule Module.LocalsTracker do
     invoked = for {n, a} <- reachable, n == name, a in min..max, do: a
 
     if invoked == [] do
-      [{:unused_def, tuple, kind} | acc]
+      [{: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]
+        ^default -> [{:unused_args, tuple}|acc]
+        unused_args -> [{:unused_args, tuple, unused_args}|acc]
       end
     end
   end
@@ -244,11 +244,11 @@ defmodule Module.LocalsTracker do
   @doc false
   def handle_call({:cache_env, env}, _from, {d, cache}) do
     case cache do
-      [{i, ^env} | _] ->
+      [{i, ^env}|_] ->
         {:reply, i, {d, cache}}
       t ->
         i = length(t)
-        {:reply, i, {d, [{i, env} | t]}}
+        {:reply, i, {d, [{i, env}|t]}}
     end
   end
 
@@ -353,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/option_parser.ex

@@ -8,10 +8,6 @@ defmodule OptionParser do
   @type errors  :: [{String.t, String.t | nil}]
   @type options :: [switches: Keyword.t, strict: Keyword.t, aliases: Keyword.t]
 
-  defmodule ParseError do
-    defexception [:message]
-  end
-
   @doc """
   Parses `argv` into a keywords list.
 
@@ -39,9 +35,8 @@ defmodule OptionParser do
 
   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.
+  conventions. This means that option names on the command line cannot contain
+  underscores; such options will be put in the invalid options list.
 
   ## Switch Definitions
 
@@ -55,42 +50,28 @@ defmodule OptionParser do
     * `: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.
+  Note that you should only supply the `:switches` or `:strict` option. If you
+  supply both, an error will be raised.
 
-  ### Types
+  For each switch, the following types are supported:
 
-  Option parser switches may take 0 or 1 argument.
+    * `: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.
 
-  The following switches take no argument:
+  If a switch can't be parsed, it is returned in the invalid options list.
 
-    * `:boolean` - sets the value to true when given
-    * `:count`   - counts the number of times the switch is given
+  The following extra "types" are supported:
 
-  The following switches take 1 argument:
-
-    * `:integer` - parses the upcoming value as an integer.
-    * `:float`   - parses the upcoming value as a float.
-    * `:string`  - parses the upcoming value as a string.
-
-  If a switch can't be parsed, 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`.
+    * `: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
-
-  Here are some examples of option parser working with different types
-  and modifiers:
+  Examples:
 
       iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
       {[unlock: true], ["path/to/file"], []}
@@ -105,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}]}
 
@@ -121,7 +96,7 @@ 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
+  ## Negation switches
 
   In case a switch is declared as boolean, it may be passed as `--no-SWITCH`
   which will set the option to `false`:
@@ -142,41 +117,6 @@ defmodule OptionParser do
     do_parse(argv, compile_config(opts), [], [], [], true)
   end
 
-  @doc """
-  The same as `parse/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there weren't any errors, returns a three-element tuple as follows:
-
-      1. parsed options,
-      2. remaining arguments,
-      3. empty list.
-
-  ## Examples
-
-      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, argv, []} -> {parsed, argv}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
   @doc """
   Similar to `parse/2` but only parses the head of `argv`;
   as soon as it finds a non-switch, it stops parsing.
@@ -197,36 +137,6 @@ defmodule OptionParser do
     do_parse(argv, compile_config(opts), [], [], [], false)
   end
 
-  @doc """
-  The same as `parse_head/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there weren't any errors, returns a three-element tuple as follows:
-
-      1. parsed options,
-      2. remaining arguments,
-      3. empty list.
-
-  ## Examples
-
-      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, errors} | no_return
-  def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse_head(argv, opts) do
-      {parsed, argv, []} -> {parsed, argv}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
   defp do_parse([], _config, opts, args, invalid, _all?) do
     {Enum.reverse(opts), Enum.reverse(args), Enum.reverse(invalid)}
   end
@@ -234,26 +144,26 @@ defmodule OptionParser 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 = 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
@@ -295,35 +205,32 @@ defmodule OptionParser do
     {:error, []}
   end
 
-  defp next(["--" | _]=argv, _aliases, _switches, _strict) do
+  defp next(["--"|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["-" | _]=argv, _aliases, _switches, _strict) do
+  defp next(["-"|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["- " <> _ | _]=argv, _aliases, _switches, _strict) do
+  defp next(["- " <> _|_]=argv, _aliases, _switches, _strict) do
     {:error, argv}
   end
 
-  defp next(["-" <> option | rest] = argv, aliases, switches, strict) do
+  defp next(["-" <> option|rest], aliases, switches, strict) do
     {option, value} = split_option(option)
-    original = "-" <> option
+    opt_name_bin = "-" <> option
     tagged = tag_option(option, switches, aliases)
 
-    cond do
-      negative_number?(original) ->
-        {:error, argv}
-      strict and not option_defined?(tagged, switches) ->
-        {:undefined, original, value, rest}
-      true ->
-        {option, kinds, value} = normalize_option(tagged, value, switches)
-        {value, kinds, rest} = normalize_value(value, kinds, rest, strict)
-        case validate_option(value, kinds) do
-          {:ok, new_value} -> {:ok, option, new_value, rest}
-          :invalid         -> {:invalid, original, value, rest}
-        end
+    if strict and not option_defined?(tagged, switches) do
+      {:undefined, opt_name_bin, value, rest}
+    else
+      {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, opt_name, new_value, rest}
+        :invalid         -> {:invalid, opt_name_bin, value, rest}
+      end
     end
   end
 
@@ -374,7 +281,7 @@ defmodule OptionParser do
   """
   @spec split(String.t) :: argv
   def split(string) do
-    do_split(String.trim_leading(string, " "), "", [], nil)
+    do_split(strip_leading_spaces(string), "", [], nil)
   end
 
   # If we have an escaped quote, simply remove the escape
@@ -395,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
@@ -407,13 +314,16 @@ 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 compile_config(opts) do
@@ -434,36 +344,30 @@ defmodule OptionParser do
   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}
@@ -472,32 +376,15 @@ defmodule OptionParser 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, switches, _aliases) do
-    cond do
-      (negated = get_option(option)) && :boolean in List.wrap(switches[negated]) ->
-        {:negated, negated}
-      option = get_option("no-" <> option) ->
-        {:default, option}
-      true ->
-        :unknown
-    end
-  end
-
-  defp tag_option("-" <> option, _switches, _aliases) do
-    if option = get_option(option) do
-      {:default, option}
-    else
-      :unknown
-    end
+  defp tag_option(<<?-, option::binary>>, switches, _aliases) do
+    get_negated(option, switches)
   end
 
   defp tag_option(option, _switches, aliases) when is_binary(option) do
@@ -538,18 +425,15 @@ defmodule OptionParser do
   end
 
   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
@@ -559,11 +443,11 @@ defmodule OptionParser 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
@@ -572,16 +456,17 @@ 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 to_underscore(<<>>, acc), do: acc
 
   defp get_option(option) do
     if str = to_underscore(option) do
@@ -589,38 +474,22 @@ defmodule OptionParser do
     end
   end
 
-  defp negative_number?(arg) do
-    match?({_, ""}, Float.parse(arg))
-  end
-
-  defp format_errors(errors, opts) do
-    types = opts[:switches] || opts[:strict]
-    info  = Enum.map(errors, &format_error(&1, opts, types))
-    total = length(errors)
-    error = if total == 1, do: "error", else: "errors"
-    "#{total} #{error} found!#{info}"
-  end
-
-  defp format_error({option, nil}, opts, types) do
-    if type = get_type(option, opts, types) do
-      "\n#{option} : Missing argument of type #{type}"
-    else
-      "\n#{option} : Unknown option"
+  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 format_error({option, value}, opts, types) do
-    type = get_type(option, opts, types)
-    "\n#{option} : Expected type #{type}, got #{inspect value}"
-  end
-
-  defp get_type(option, opts, types) do
-    option_key = option |> String.trim_leading("-") |> get_option()
-
-    if option_alias = opts[:aliases][option_key] do
-      types[option_alias]
+  defp get_negated(rest, _switches) do
+    if option = get_option(rest) do
+      {:default, option}
     else
-      types[option_key]
+      :unknown
     end
   end
 end

lib/elixir/lib/path.ex

@@ -3,13 +3,13 @@ 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
@@ -69,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)
@@ -87,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,26 +100,26 @@ defmodule Path do
     do_absname_join(rest, relativename, [?:, uc_letter+?a-?A], :win32)
   defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32), do:
     do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/|result], os_type), do:
+    do_absname_join(rest, relativename, [?/|result], os_type)
+  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/|result], os_type), do:
+    do_absname_join(rest, relativename, [?/|result], os_type)
   defp do_absname_join(<<>>, <<>>, result, os_type), do:
     IO.iodata_to_binary(reverse_maybe_remove_dirsep(result, os_type))
-  defp do_absname_join(<<>>, relativename, [?: | rest], :win32), do:
-    do_absname_join(relativename, <<>>, [?: | rest], :win32)
-  defp do_absname_join(<<>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(relativename, <<>>, [?/ | result], os_type)
+  defp do_absname_join(<<>>, relativename, [?:|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_dirsep([?/, ?:, letter], :win32), do:
     [letter, ?:, ?/]
   defp reverse_maybe_remove_dirsep([?/], _), do:
     [?/]
-  defp reverse_maybe_remove_dirsep([?/ | name], _), do:
+  defp reverse_maybe_remove_dirsep([?/|name], _), do:
     :lists.reverse(name)
   defp reverse_maybe_remove_dirsep(name, _), do:
     :lists.reverse(name)
@@ -131,7 +131,7 @@ defmodule Path do
   ## Examples
 
       Path.expand("/foo/bar/../bar")
-      #=> "/foo/bar"
+      "/foo/bar"
 
   """
   @spec expand(t) :: binary
@@ -227,19 +227,19 @@ defmodule Path do
 
   defp unix_pathtype(<<?/, relative::binary>>), do:
     {:absolute, relative}
-  defp unix_pathtype([?/ | relative]), do:
+  defp unix_pathtype([?/|relative]), do:
     {:absolute, relative}
-  defp unix_pathtype([list | rest]) when is_list(list), do:
+  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:
+  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([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:
@@ -253,8 +253,8 @@ defmodule Path 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([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:
@@ -290,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
 
@@ -363,11 +363,10 @@ defmodule Path do
 
   ## Examples
 
-      iex> Path.dirname("/foo/bar.ex")
-      "/foo"
-
-      iex> Path.dirname("/foo/bar/baz.ex")
-      "/foo/bar"
+      Path.dirname("/foo/bar.ex")
+      #=> "/foo"
+      Path.dirname("/foo/bar/baz.ex")
+      #=> "/foo/bar"
 
   """
   @spec dirname(t) :: binary
@@ -446,8 +445,8 @@ defmodule Path do
 
   """
   @spec join([t]) :: binary
-  def join([name1, name2 | rest]), do:
-    join([join(name1, name2) | rest])
+  def join([name1, name2|rest]), do:
+    join([join(name1, name2)|rest])
   def join([name]), do:
     name
 
@@ -471,11 +470,10 @@ defmodule Path do
   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, "", _os_type),   do: left
   defp do_join(left, right, os_type), do: remove_dirsep(left, os_type) <> "/" <> relative(right, os_type)
 
   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
@@ -562,14 +560,10 @@ 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
@@ -644,17 +638,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

@@ -3,9 +3,9 @@ defmodule Port do
   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 """

lib/elixir/lib/process.ex

@@ -28,7 +28,7 @@ defmodule Process do
   end
 
   @doc """
-  Returns all key-value pairs in the process dictionary.
+  Returns all key-values in the dictionary.
 
   Inlined by the compiler.
   """
@@ -38,7 +38,7 @@ defmodule Process do
   end
 
   @doc """
-  Returns the value for the given `key` or `default` if `key` is not set.
+  Returns the value for the given `key`.
   """
   @spec get(term) :: term
   @spec get(term, default :: term) :: term
@@ -72,7 +72,7 @@ defmodule Process do
   end
 
   @doc """
-  Stores the given `key`-`value` pair in the process dictionary.
+  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`).
@@ -83,7 +83,7 @@ defmodule Process do
   end
 
   @doc """
-  Deletes the given `key` from the process dictionary.
+  Deletes the given `key` from the dictionary.
   """
   @spec delete(term) :: term | nil
   def delete(key) do
@@ -91,27 +91,23 @@ defmodule Process do
   end
 
   @doc """
-  Sends an exit signal with the given `reason` to the `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.
 
-    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.
+    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.
 
-    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`.
+    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.
 
@@ -125,80 +121,6 @@ defmodule Process do
     :erlang.exit(pid, reason)
   end
 
-  @doc """
-  Sleeps the current process by `timeout`.
-
-  `timeout` is either the number of milliseconds to sleep as an
-  integer or the atom `:infinity`. When `:infinity` is given,
-  the current process will suspend forever.
-
-  **Use this function with extreme care**. For almost all situations
-  where you would use `sleep/1` in Elixir, there is likely a
-  more correct, faster and precise way of achieving it with
-  message passing.
-
-  For example, if you are waiting a process to perform some
-  action, it is better to communicate.
-
-  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
-
-  Or even use `Task.async/1` and `Task.await/2` in the example
-  above.
-
-  Similarly, if you are waiting for a process to terminate,
-  use monitor instead of sleep. **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
-
-  """
-  def sleep(timeout)
-      when is_integer(timeout) and timeout >= 0
-      when timeout == :infinity do
-    receive after: (timeout -> :ok)
-  end
-
   @doc """
   Sends a message to the given process.
 
@@ -249,8 +171,8 @@ defmodule Process do
   @doc """
   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 be either because the timer expired, already has
@@ -269,7 +191,7 @@ defmodule Process do
   @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
@@ -293,7 +215,8 @@ 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
@@ -311,7 +234,7 @@ defmodule Process do
   end
 
   @doc """
-  Spawns the given function 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,
@@ -330,7 +253,7 @@ defmodule Process do
   end
 
   @doc """
-  The calling process starts monitoring the given `item`.
+  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)
@@ -402,22 +325,21 @@ defmodule Process do
   end
 
   @doc """
-  Associates the atom `name` with a `pid` or a port identifier.
+  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.
 
-  `name`, can then be used instead of the `pid` / port identifier with the `Kernel.send/2`
-  function. `Process.register/2` will fail with `ArgumentError` if the pid supplied
-  is no longer alive, (check with `alive?/1`) or if the name is already registered
-  (check with `whereis/1`) or if the `pid` is already registered to a different `name`.
+  `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] and is_atom(name) do
+  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.
-
-  Fails with `ArgumentError` if the name is not registered to any pid or port.
+  Removes the registered name, associated with a pid or a port identifier.
 
   See [`:erlang.unregister/1`](http://www.erlang.org/doc/man/erlang.html#unregister-1) for more info.
   """
@@ -427,7 +349,7 @@ defmodule Process do
   end
 
   @doc """
-  Returns the pid or port identifier with the registered `name`.
+  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.
@@ -467,7 +389,7 @@ defmodule Process do
                          :sensitive
   @doc """
   Sets certain flags for the process which calls this function.
-  Returns the old value of the `flag`.
+  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.
   """
@@ -478,8 +400,8 @@ defmodule Process do
 
   @doc """
   Sets certain flags for the process `pid`, in the same manner as `flag/2`.
-  Returns the old value of the `flag`. The allowed values for `flag` are
-  only a subset of those allowed in `flag/2`, namely `:save_calls`.
+  Returns the old value of 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.
   """
@@ -489,7 +411,7 @@ defmodule Process do
   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.
 
@@ -501,8 +423,8 @@ defmodule Process do
   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.
   """

lib/elixir/lib/protocol.ex

@@ -31,7 +31,7 @@ defmodule Protocol 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
@@ -56,7 +56,7 @@ defmodule Protocol do
   @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,9 +174,9 @@ 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[:impl] do
@@ -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
@@ -290,7 +290,7 @@ defmodule Protocol do
   # impl_for/1 dispatch version.
   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, docs}
@@ -298,7 +298,7 @@ defmodule Protocol do
     end
   end
 
-  defp change_impl_for([{:function, line, :__protocol__, 1, clauses} | t], protocol, types, structs, _, acc) do
+  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}]}
@@ -307,34 +307,34 @@ defmodule Protocol do
     end, clauses)
 
     change_impl_for(t, protocol, types, structs, true,
-                    [{:function, line, :__protocol__, 1, clauses} | acc])
+                    [{:function, line, :__protocol__, 1, clauses}|acc])
   end
 
-  defp change_impl_for([{:function, line, :impl_for, 1, _} | t], protocol, types, structs, is_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(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :impl_for, 1, clauses} | acc])
+                    [{:function, line, :impl_for, 1, clauses}|acc])
   end
 
-  defp change_impl_for([{:function, line, :struct_impl_for, 1, _} | t], protocol, types, structs, is_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(t, protocol, types, structs, is_protocol,
-                    [{:function, line, :struct_impl_for, 1, clauses} | acc])
+                    [{:function, line, :struct_impl_for, 1, clauses}|acc])
   end
 
-  defp change_impl_for([h | t], protocol, info, types, is_protocol, acc) do
-    change_impl_for(t, protocol, info, types, is_protocol, [h | 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([], protocol, _info, _types, is_protocol, acc) do
@@ -386,12 +386,11 @@ defmodule Protocol do
   # Finally compile the module and emit its bytecode.
   defp compile({protocol, code}, docs) do
     opts = if Code.compiler_options[:debug_info], do: [:debug_info], else: []
-    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return | opts])
-    {:ok,
-      case docs do
-        :missing_chunk -> binary
-        _ -> :elixir_module.add_beam_chunk(binary, @docs_chunk, docs)
-      end}
+    {: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
@@ -426,9 +425,8 @@ defmodule Protocol do
   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.
@@ -451,8 +449,7 @@ defmodule Protocol do
         end
       end, builtin)
 
-      @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
@@ -504,7 +501,7 @@ defmodule Protocol do
   @doc false
   def __functions_spec__([]),
     do: []
-  def __functions_spec__([h | t]),
+  def __functions_spec__([h|t]),
     do: [:lists.foldl(&{:|, [], [&1, &2]}, h, t), quote(do: ...)]
 
   @doc false
@@ -536,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 dict[key] syntax, please implement the Dict behaviour instead"
+      else
+        Protocol.assert_protocol!(protocol)
+        Protocol.__ensure_defimpl__(protocol, for, __ENV__)
+      end
 
       defmodule name do
         @behaviour protocol
@@ -635,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

@@ -21,28 +21,13 @@ defmodule Range do
       iex> last
       3
 
-  A Range implements the Enumerable protocol, which means
-  all of the functions in the Enum module is available:
-
-      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.
   """
@@ -58,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
 
@@ -69,14 +56,15 @@ 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
+  def reduce(first .. last, acc, fun) do
     reduce(first, last, acc, fun, last >= first)
   end
 
@@ -100,7 +88,7 @@ defimpl Enumerable, for: Range 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
@@ -108,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
@@ -124,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

@@ -85,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
@@ -116,13 +116,14 @@ 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
@@ -178,7 +179,7 @@ defmodule Record do
 
   ## Defining extracted records with anonymous functions
 
-  If a record defines an anonymous function, an `ArgumentError`
+  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.
@@ -259,8 +260,8 @@ defmodule Record do
         create(atom, fields, args, caller)
       true ->
         case Macro.expand(args, caller) do
-          {:{}, _, [^atom | list]} when length(list) == length(fields) ->
-            record = List.to_tuple([atom | list])
+          {:{}, _, [^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}))
@@ -296,15 +297,17 @@ defmodule Record do
   # Creates a new record with the given default fields and keyword values.
   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)}
@@ -312,7 +315,7 @@ defmodule Record do
 
     case remaining do
       [] ->
-        {:{}, [], [atom | match]}
+        {:{}, [], [atom|match]}
       _  ->
         keys = for {key, _} <- remaining, do: key
         raise ArgumentError, "record #{inspect atom} does not have the key: #{inspect hd(keys)}"
@@ -325,8 +328,6 @@ defmodule Record 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
@@ -351,15 +352,15 @@ defmodule Record do
     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__(atom, fields, record) do
     if is_record(record, atom) do
-      [_tag | values] = Tuple.to_list(record)
+      [_tag|values] = Tuple.to_list(record)
       join_keyword(fields, values, [])
     else
       msg = "expected argument to be a literal atom, literal keyword or a #{inspect atom} record, got runtime: #{inspect record}"
@@ -367,20 +368,8 @@ defmodule Record do
     end
   end
 
-  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 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

@@ -13,7 +13,7 @@ defmodule Regex do
       # 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
 
   A Regex is represented internally as the `Regex` struct. Therefore,
@@ -23,9 +23,9 @@ defmodule Regex do
 
   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) - add case insensitivity
 
@@ -135,7 +135,7 @@ defmodule Regex do
   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
@@ -173,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
@@ -347,9 +348,6 @@ 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")
@@ -370,12 +368,6 @@ defmodule Regex do
       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 \\ [])
@@ -394,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 ->
@@ -406,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
 
@@ -509,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
@@ -535,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
@@ -549,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
@@ -617,14 +591,14 @@ 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])
+  {:ok, pattern} = :re.compile(~S"[.^$*+?()[{\\\|\s#]", [:unicode])
   @escape_pattern pattern
 
   @doc ~S"""
@@ -658,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

@@ -9,7 +9,21 @@ defmodule Set do
   @type values :: [ value ]
   @type t :: map
 
-  # TODO: Deprecate every function by 1.4
+  # 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
       case unquote(set) do

lib/elixir/lib/stream.ex

@@ -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
@@ -109,13 +110,13 @@ defmodule Stream do
   end
 
   defmacrop acc(h, n, t) do
-    quote do: [unquote(h), unquote(n) | unquote(t)]
+    quote do: [unquote(h), unquote(n)|unquote(t)]
   end
 
   defmacrop next_with_acc(f, entry, h, n, t) do
     quote do
-      {reason, [h | t]} = unquote(f).(unquote(entry), [unquote(h) | unquote(t)])
-      {reason, [h, unquote(n) | t]}
+      {reason, [h|t]} = unquote(f).(unquote(entry), [unquote(h)|unquote(t)])
+      {reason, [h, unquote(n)|t]}
     end
   end
 
@@ -134,9 +135,9 @@ defmodule Stream do
   `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 `leftover` if it was passed. If `leftover` is passed and
-  does not have enough elements to fill the chunk, then the chunk is
-  returned anyway with less than `n` elements. If `leftover` is not
+  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.
 
@@ -157,15 +158,14 @@ defmodule Stream do
   """
   @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, leftover \\ nil)
-      when is_integer(n) and n > 0 and is_integer(step) and step > 0 do
+  def chunk(enum, n, step, pad \\ nil) when n > 0 and step > 0 do
     limit = :erlang.max(n, step)
-    if is_nil(leftover) do
+    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, leftover, &2)
+           &do_chunk(&1, n, pad, &2)
      end
   end
 
@@ -173,8 +173,8 @@ defmodule Stream do
     {:cont, acc}
   end
 
-  defp do_chunk(acc(h, {buffer, count} = old, t), n, leftover, f1) do
-    buffer = :lists.reverse(buffer, Enum.take(leftover, n - count))
+  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
 
@@ -270,53 +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, or `FunctionClauseError` will be thrown.
-
-  ## 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, 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`.
@@ -362,7 +332,7 @@ defmodule Stream do
 
   @doc """
   Creates a stream that will apply the given function on enumeration and
-  flatten the result, but only one level deep.
+  flatten the result.
 
   ## Examples
 
@@ -370,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
@@ -415,12 +381,9 @@ defmodule Stream do
   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.
 
   ## Examples
 
@@ -428,9 +391,10 @@ 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) ->
+    unfold 0, fn (count) ->
       :timer.sleep(n)
       {count, count + 1}
     end
@@ -449,26 +413,26 @@ defmodule Stream do
 
   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
@@ -651,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
 
@@ -735,7 +698,7 @@ defmodule Stream do
 
   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} ->
+      {:suspended, [val|next_acc], next} ->
         try do
           user.(val, user_acc)
         catch
@@ -787,7 +750,7 @@ defmodule Stream 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
@@ -797,15 +760,15 @@ defmodule Stream do
     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 ->
+      {:halted, [:outer|acc]} when op != :halt ->
         do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
-      {:halted, [_ | acc]} ->
+      {:halted, [_|acc]} ->
         next.({:halt, next_acc})
         do_after(after_fun, user_acc)
         {:halted, acc}
-      {:done, [_ | acc]} ->
+      {:done, [_|acc]} ->
         do_transform(user_acc, user, fun, next_acc, next, {:cont, acc}, inner, after_fun)
-      {:suspended, [_ | acc], c} ->
+      {:suspended, [_|acc], c} ->
         {:suspended, acc, &do_enum_transform(user_acc, user, fun, next_acc, next, &1, inner, c, after_fun)}
     end
   end
@@ -813,15 +776,15 @@ defmodule Stream do
   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 """
@@ -954,10 +917,10 @@ defmodule Stream do
     end
   end
 
-  defp do_zip([{fun, fun_acc} | t], acc, callback, list, buffer) do
+  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])
+      {: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}
@@ -970,13 +933,13 @@ defmodule Stream do
   end
 
   defp do_zip_close([]), do: :ok
-  defp do_zip_close([{fun, acc} | t]) do
+  defp do_zip_close([{fun, acc}|t]) do
     fun.({:halt, acc})
     do_zip_close(t)
   end
 
   defp do_zip_step(x, acc) do
-    {:suspend, [x | acc]}
+    {:suspend, [x|acc]}
   end
 
   ## Sources
@@ -1091,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).
 
@@ -1116,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
@@ -1178,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
 
@@ -1241,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
@@ -1281,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
@@ -1291,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

@@ -5,7 +5,7 @@ defmodule Stream.Reducers do
   defmacro chunk(n, step, limit, f \\ nil) do
     quote do
       fn entry, acc(h, {buffer, count}, t) ->
-        buffer = [entry | buffer]
+        buffer = [entry|buffer]
         count  = count + 1
 
         new =
@@ -31,7 +31,7 @@ defmodule Stream.Reducers do
         entry, acc(h, {buffer, value}, t) ->
           new_value = unquote(callback).(entry)
           if new_value == value do
-            skip(acc(h, {[entry | buffer], value}, t))
+            skip(acc(h, {[entry|buffer], value}, t))
           else
             next_with_acc(unquote(f), :lists.reverse(buffer), h, {[entry], new_value}, t)
           end
@@ -64,18 +64,6 @@ defmodule Stream.Reducers do
     end
   end
 
-  defmacro drop_every(nth, f \\ nil) do
-    quote do
-      fn
-        entry, acc(h, n, t) when n === :first
-                            when n === unquote(nth) ->
-          skip(acc(h, 1, t))
-        entry, acc(h, n, t) ->
-          next_with_acc(unquote(f), entry, h, n+1, t)
-      end
-    end
-  end
-
   defmacro drop_while(callback, f \\ nil) do
     quote do
       fn entry, acc(h, bool, t) = orig ->

lib/elixir/lib/string/chars.ex

@@ -14,7 +14,7 @@ defprotocol String.Chars do
   as `"foo" <> to_string(bar)`.
   """
 
-  def to_string(term)
+  def to_string(thing)
 end
 
 defimpl String.Chars, for: Atom do
@@ -28,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.
@@ -46,8 +40,7 @@ defmodule StringIO do
   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,17 +196,6 @@ 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,
@@ -222,14 +204,11 @@ defmodule StringIO do
       {:error, _} = error ->
         {error, s}
       {result, input} ->
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, IO.chardata_to_string(prompt)::binary>>}
-          else
-            s
-          end
+        if capture_prompt do
+          output = <<output::binary, IO.chardata_to_string(prompt)::binary>>
+        end
 
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -273,14 +252,11 @@ defmodule StringIO do
       chars ->
         {result, input} = do_get_line(chars, encoding)
 
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, IO.chardata_to_string(prompt)::binary>>}
-          else
-            s
-          end
+        if capture_prompt do
+          output = <<output::binary, IO.chardata_to_string(prompt)::binary>>
+        end
 
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -306,20 +282,17 @@ defmodule StringIO do
       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
 
-        s =
-          if capture_prompt do
-            %{s | output: <<output::binary, :binary.copy(IO.chardata_to_string(prompt), count)::binary>>}
-          else
-            s
-          end
-
-        {result, %{s | input: input}}
+        {result, %{s | input: input, output: output}}
     end
   end
 
@@ -338,10 +311,11 @@ defmodule StringIO do
     {line, rest} = collect_line(chars)
 
     case apply(mod, fun, [continuation, line | args]) do
-      {:done, result, :eof} ->
+      {:done, result, rest1} ->
+        unless rest1 == :eof do
+          rest = rest1 ++ rest
+        end
         {result, rest, count + 1}
-      {:done, result, extra} ->
-        {result, extra ++ rest, count + 1}
       {:more, next_continuation} ->
         do_get_until(rest, encoding, mod, fun, args, next_continuation, count + 1)
     end
@@ -349,7 +323,7 @@ defmodule StringIO do
 
   ## 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
 
@@ -368,15 +342,15 @@ defmodule StringIO do
   end
 
   defp collect_line([?\r, ?\n | rest], stack) do
-    {:lists.reverse([?\n | stack]), rest}
+    {:lists.reverse([?\n|stack]), rest}
   end
 
   defp collect_line([?\n | rest], stack) do
-    {:lists.reverse([?\n | stack]), rest}
+    {:lists.reverse([?\n|stack]), rest}
   end
 
-  defp collect_line([h | t], stack) do
-    collect_line(t, [h | stack])
+  defp collect_line([h|t], stack) do
+    collect_line(t, [h|stack])
   end
 
   defp io_reply(from, reply_as, reply) do

lib/elixir/lib/supervisor.ex

@@ -2,16 +2,16 @@ defmodule Supervisor do
   @moduledoc ~S"""
   A behaviour module for implementing supervision functionality.
 
-  A supervisor is a process which supervises other processes, which we refer
-  to as *child processes*. Supervisors are used to build a hierarchical process
-  structure called a *supervision tree*. Supervision trees are a nice way to
-  structure fault-tolerant applications.
+  A supervisor is a process which supervises other processes, called
+  child processes. Supervisors are used to build a hierarchical process
+  structure called a supervision tree, a nice way to structure fault-tolerant
+  applications.
 
-  A supervisor implemented using this module has a standard set
-  of interface functions and includes functionality for tracing and error
-  reporting. It also fits into a supervision tree.
+  A supervisor 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.
 
-  ## Examples
+  ## Example
 
   In order to define a supervisor, we need to first define a child process
   that is going to be supervised. In order to do so, we will define a GenServer
@@ -24,12 +24,12 @@ defmodule Supervisor do
           GenServer.start_link(__MODULE__, state, opts)
         end
 
-        def handle_call(:pop, _from, [h | t]) do
+        def handle_call(:pop, _from, [h|t]) do
           {:reply, h, t}
         end
 
         def handle_cast({:push, h}, t) do
-          {:noreply, [h | t]}
+          {:noreply, [h|t]}
         end
       end
 
@@ -38,56 +38,56 @@ defmodule Supervisor do
       # Import helpers for defining supervisors
       import Supervisor.Spec
 
-      # Supervise the Stack server which will be started with
-      # a single argument [:hello] and the default registered
-      # name of MyStack.
+      # We are going to supervise the Stack server which
+      # will be started with a single argument [:hello]
+      # and the default name of :sup_stack.
       children = [
-        worker(Stack, [[:hello], [name: MyStack]])
+        worker(Stack, [[:hello], [name: :sup_stack]])
       ]
 
-      # Start the supervisor with our child
+      # Start the supervisor with our one child
       {:ok, pid} = Supervisor.start_link(children, strategy: :one_for_one)
 
   Notice that when starting the GenServer, we are registering it
-  with name `MyStack`, which allows us to call it directly and
+  with name `:sup_stack`, which allows us to call it directly and
   get what is on the stack:
 
-      GenServer.call(MyStack, :pop)
+      GenServer.call(:sup_stack, :pop)
       #=> :hello
 
-      GenServer.cast(MyStack, {:push, :world})
+      GenServer.cast(:sup_stack, {:push, :world})
       #=> :ok
 
-      GenServer.call(MyStack, :pop)
+      GenServer.call(:sup_stack, :pop)
       #=> :world
 
   However, there is a bug in our stack server. If we call `:pop` and
-  the stack is empty, it is going to crash because no clause matches:
+  the stack is empty, it is going to crash because no clause matches.
+  Let's try it:
 
       GenServer.call(:sup_stack, :pop)
-      ** (exit) exited in: GenServer.call(MyStack, :pop, 5000)
+      ** (exit) exited in: GenServer.call(:sup_stack, :pop, 5000)
 
   Luckily, since the server is being supervised by a supervisor, the
-  supervisor will automatically start a new one, with the initial stack
-  of `[:hello]`:
+  supervisor will automatically start a new one, with the default stack
+  of `[:hello]` like before:
 
-      GenServer.call(MyStack, :pop)
-      #=> :hello
+      GenServer.call(:sup_stack, :pop) == :hello
 
   Supervisors support different strategies; in the example above, we
   have chosen `:one_for_one`. Furthermore, each supervisor can have many
   workers and supervisors as children, each of them with their specific
   configuration, shutdown values, and restart strategies.
 
-  The rest of this documentation will cover supervision strategies; also read
-  the documentation for the `Supervisor.Spec` module to learn about the
-  specification for workers and supervisors.
+  Continue reading this moduledoc to learn more about supervision strategies
+  and then proceed to the `Supervisor.Spec` module documentation to learn
+  about the specification for workers and supervisors.
 
   ## Module-based supervisors
 
-  In the example above, a supervisor was started by passing the supervision
-  structure to `start_link/2`. However, supervisors can also be created by
-  explicitly defining a supervision module:
+  In the example above, a supervisor was dynamically created by passing
+  the supervision structure to `start_link/2`. However, supervisors
+  can also be created by explicitly defining a supervision module:
 
       defmodule MyApp.Supervisor do
         use Supervisor
@@ -101,7 +101,6 @@ defmodule Supervisor do
             worker(Stack, [[:hello]])
           ]
 
-          # supervise/2 is imported from Supervisor.Spec
           supervise(children, strategy: :one_for_one)
         end
       end
@@ -120,9 +119,6 @@ defmodule Supervisor do
 
   ## Strategies
 
-  Supervisors support different supervision strategies (through the `:strategy`
-  option, as seen above):
-
     * `:one_for_one` - if a child process terminates, only that
       process is restarted.
 
@@ -131,7 +127,7 @@ defmodule Supervisor do
       the terminated one) are restarted.
 
     * `:rest_for_one` - if a child process terminates, the "rest" of
-      the child processes, i.e., the child processes after the terminated
+      the child processes, i.e. the child processes after the terminated
       one in start order, are terminated. Then the terminated child
       process and the rest of the child processes are restarted.
 
@@ -143,10 +139,10 @@ defmodule Supervisor do
 
   ## Simple one for one
 
-  The `:simple_one_for_one` supervisor is useful when you want to dynamically
-  start and stop supervised children. For example, imagine you want to
-  dynamically create multiple stacks. We can do so by defining a `:simple_one_for_one`
-  supervisor:
+  The simple one for one supervisor is useful when you want to dynamically
+  start and stop supervisor children. For example, imagine you want to
+  dynamically create multiple stacks. We can do so by defining a simple one
+  for one supervisor:
 
       # Import helpers for defining supervisors
       import Supervisor.Spec
@@ -162,16 +158,15 @@ defmodule Supervisor do
 
   There are a couple differences here:
 
-    * the simple one for one specification can define only one child which
+    * The simple one for one specification can define only one child which
       works as a template for when we call `start_child/2`
 
-    * we have defined the child to have a restart strategy of `:transient`. This
-      means that, if the child process exits due to a `:normal`, `:shutdown`,
+    * We have defined the child to have a restart strategy of transient. This
+      means that, if the child process exits due to a `:normal`, `:shutdown`
       or `{:shutdown, term}` reason, it won't be restarted. This is useful
       as it allows our workers to politely shutdown and be removed from the
-      `:simple_one_for_one` supervisor, without being restarted. You can find
-      more information about restart strategies in the documentation for the
-      `Supervisor.Spec` module
+      simple one for one supervisor, without being restarted. You can find
+      more information about restart strategies on `Supervisor.Spec`
 
   With the supervisor defined, let's dynamically start stacks:
 
@@ -188,48 +183,38 @@ defmodule Supervisor do
 
   ## Exit reasons
 
-  From the example above, you may have noticed that the `:transient` restart
-  strategy for the worker does not restart the child in case it exits with
+  From the example above, you may have noticed that the transient restart
+  strategy for the worker does not restart the child in case it crashes with
   reason `:normal`, `:shutdown` or `{:shutdown, term}`.
 
   So one may ask: which exit reason should I choose when exiting my worker?
   There are three options:
 
     * `:normal` - in such cases, the exit won't be logged, there is no restart
-      in transient mode, and linked processes do not exit
+      in transient mode and linked processes do not exit
 
     * `:shutdown` or `{:shutdown, term}` - in such cases, the exit won't be
-      logged, there is no restart in transient mode, and linked processes exit
-      with the same reason unless they're trapping exits
+      logged, there is no restart in transient mode and linked processes exit
+      with the same reason unless trapping exits
 
     * any other term - in such cases, the exit will be logged, there are
-      restarts in transient mode, and linked processes exit with the same reason
-      unless they're trapping exits
+      restarts in transient mode and linked processes exit with the same reason
+      unless trapping exits
 
-  ## Name registration
+  ## Name Registration
 
   A supervisor is bound to the same name registration rules as a `GenServer`.
-  Read more about these rules in the documentation for `GenServer`.
-
+  Read more about it in the `GenServer` docs.
   """
 
   @doc false
   defmacro __using__(_) do
     quote location: :keep do
-      @behaviour Supervisor
+      @behaviour :supervisor
       import Supervisor.Spec
     end
   end
 
-  @doc """
-  Callback invoked to start the supervisor and during hot code upgrades.
-  """
-  # TODO: Support {:ok, [child_spec], Keyword.t}
-  # TODO: Document options here and update Supervisor.Spec
-  @callback init(args :: term) ::
-    {:ok, {:supervisor.sup_flags, [Supervisor.Spec.spec]}} |
-    :ignore
-
   @typedoc "Return values of `start_link` functions"
   @type on_start :: {:ok, pid} | :ignore |
                     {:error, {:already_started, pid} | {:shutdown, term} | term}
@@ -255,29 +240,30 @@ defmodule Supervisor do
   @doc """
   Starts a supervisor with the given children.
 
-  A strategy is required to be provided through the `:strategy` option.
-  Furthermore, the `:max_restarts` and `:max_seconds` options can be
-  configured as described in the documentation for `Supervisor.Spec.supervise/2`.
+  A strategy is required to be given as an option. Furthermore,
+  the `:max_restarts` and `:max_seconds` value can be configured
+  as described in `Supervisor.Spec.supervise/2` docs.
 
   The options can also be used to register a supervisor name.
-  The supported values are described under the "Name registration"
+  The supported values are described under the `Name Registration`
   section in the `GenServer` module docs.
 
   If the supervisor and its child processes are successfully created
-  (i.e., if the start function of each child process returns `{:ok, child}`,
-  `{:ok, child, info}`, or `:ignore`) this function returns
-  `{:ok, pid}`, where `pid` is the pid of the supervisor. If a process with the
-   specified name already exists, the function returns `{:error,
-   {:already_started, pid}}`, where `pid` is the pid of that process.
+  (i.e. if the start function of all child processes returns `{:ok, child}`,
+  `{:ok, child, info}`, or `:ignore`) the function returns
+  `{:ok, pid}`, where `pid` is the pid of the supervisor. If there
+  already exists a process with the specified name, the function returns
+  `{:error, {:already_started, pid}}`, where pid is the pid of that
+  process.
 
-  If the start function of any of the child processes fails or returns an error
-  tuple or an erroneous value, the supervisor first terminates with reason
-  `:shutdown` all the child processes that have already been started, and then
-  terminates itself and returns `{:error, {:shutdown, reason}}`.
+  If any of the child process start functions fail or return an error tuple or
+  an erroneous value, the supervisor will first terminate all already
+  started child processes with reason `:shutdown` and then terminate
+  itself and return `{:error, {:shutdown, reason}}`.
 
-  Note that a supervisor started with this function is linked to the parent
-  process and exits not only on crashes but also if the parent process exits
-  with `:normal` reason.
+  Note that the `Supervisor` 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([Supervisor.Spec.spec], options) :: on_start
   def start_link(children, options) when is_list(children) do
@@ -288,10 +274,10 @@ defmodule Supervisor do
   @doc """
   Starts a supervisor module with the given `arg`.
 
-  To start the supervisor, the `init/1` callback will be invoked in the given
-  `module`, with `arg` as its argument. The `init/1` callback must return a
-  supervisor specification which can be created with the help of the functions
-  in the `Supervisor.Spec` module (especially `Supervisor.Spec.supervise/2`).
+  To start the supervisor, the `init/1` callback will be invoked
+  in the given module. The `init/1` callback must return a
+  supervision specification which can be created with the help
+  of `Supervisor.Spec` module.
 
   If the `init/1` callback returns `:ignore`, this function returns
   `:ignore` as well and the supervisor terminates with reason `:normal`.
@@ -300,8 +286,10 @@ defmodule Supervisor do
   error, and the supervisor terminates with reason `term`.
 
   The `:name` option can also be given in order to register a supervisor
-  name, the supported values are described in the "Name registration"
+  name, the supported values are described under the `Name Registration`
   section in the `GenServer` module docs.
+
+  Other failure conditions are specified in `start_link/2` docs.
   """
   @spec start_link(module, term) :: on_start
   @spec start_link(module, term, options) :: on_start
@@ -317,34 +305,33 @@ defmodule Supervisor do
   end
 
   @doc """
-  Dynamically adds a child specification to `supervisor` and starts that child.
+  Dynamically adds and starts a child specification to the supervisor.
 
   `child_spec` should be a valid child specification (unless the supervisor
   is a `:simple_one_for_one` supervisor, see below). The child process will
   be started as defined in the child specification.
 
   In the case of `:simple_one_for_one`, the child specification defined in
-  the supervisor is used and instead of a `child_spec`, an arbitrary list
+  the supervisor will be used and instead of a `child_spec`, an arbitrary list
   of terms is expected. The child process will then be started by appending
   the given list to the existing function arguments in the child specification.
 
-  If a child specification with the specified id already exists, `child_spec` is
-  discarded and this function returns an error with `:already_started` or
-  `:already_present` if the corresponding child process is running or not,
-  respectively.
+  If a child specification with the specified id already exists,
+  `child_spec` is discarded and the function returns an error with `:already_started`
+  or `:already_present` if the corresponding child process is running or not.
 
-  If the child process start function returns `{:ok, child}` or `{:ok, child,
-  info}`, then child specification and pid are added to the supervisor and
-  this function returns the same value.
+  If the child process starts, function returns `{:ok, child}` or `{:ok, child, info}`,
+  the child specification and pid is added to the supervisor and the function returns
+  the same value.
 
-  If the child process start function returns `:ignore`, the child specification
-  is added to the supervisor, the pid is set to `:undefined` and this function
-  returns `{:ok, :undefined}`.
+  If the child process starts, function returns `:ignore`, the child specification is
+  added to the supervisor, the pid is set to undefined and the function returns
+  `{:ok, :undefined}`.
 
-  If the child process start function returns an error tuple or an erroneous
-  value, or if it fails, the child specification is discarded and this function
-  returns `{:error, error}` where `error` is a term containing information about
-  the error and child specification.
+  If the child process starts, function returns an error tuple or an erroneous value,
+  or if it fails, the child specification is discarded and the function returns
+  `{:error, error}` where `error` is a term containing information about the error
+  and child specification.
   """
   @spec start_child(supervisor, Supervisor.Spec.spec | [term]) :: on_start_child
   def start_child(supervisor, child_spec_or_args) do
@@ -352,23 +339,22 @@ defmodule Supervisor do
   end
 
   @doc """
-  Terminates the given children, identified by pid or child id.
+  Terminates the given pid or child id.
 
-  If the supervisor is not a `:simple_one_for_one`, the child id is expected
-  and the process, if there's one, is terminated; the child specification is
+  If the supervisor is not a `simple_one_for_one`, the child id is expected
+  and the process, if there is one, is terminated; the child specification is
   kept unless the child is temporary.
 
-  In case of a `:simple_one_for_one` supervisor, a pid is expected. If the child
-  specification identifier is given instead of a `pid`, this function returns
-  `{:error, :simple_one_for_one}`.
+  In case of a `simple_one_for_one` supervisor, a pid is expected. If the child
+  specification identifier is given instead of a `pid`, the function will
+  return `{:error, :simple_one_for_one}`.
 
   A non-temporary child process may later be restarted by the supervisor. The child
   process can also be restarted explicitly by calling `restart_child/2`. Use
   `delete_child/2` to remove the child specification.
 
-  If successful, this function returns `:ok`. If there is no child specification
-  for the given child id or there is no process with the given pid, this
-  function returns `{:error, :not_found}`.
+  If successful, the function returns `:ok`. If there is no child specification or
+  pid, the function returns `{:error, :not_found}`.
   """
   @spec terminate_child(supervisor, pid | Supervisor.Spec.child_id) :: :ok | {:error, error}
         when error: :not_found | :simple_one_for_one
@@ -379,14 +365,14 @@ defmodule Supervisor do
   @doc """
   Deletes the child specification identified by `child_id`.
 
-  The corresponding child process must not be running; use `terminate_child/2`
-  to terminate it if it's running.
+  The corresponding child process must not be running, use `terminate_child/2`
+  to terminate it.
 
-  If successful, this function returns `:ok`. This function may return an error
-  with an appropriate error tuple if the `child_id` is not found, or if the
-  current process is running or being restarted.
+  If successful, the function returns `:ok`. This function may error with an
+  appropriate error tuple if the `child_id` is not found, or if the current
+  process is running or being restarted.
 
-  This operation is not supported by `:simple_one_for_one` supervisors.
+  This operation is not supported by `simple_one_for_one` supervisors.
   """
   @spec delete_child(supervisor, Supervisor.Spec.child_id) :: :ok | {:error, error}
         when error: :not_found | :simple_one_for_one | :running | :restarting
@@ -403,20 +389,20 @@ defmodule Supervisor do
   Note that for temporary children, the child specification is automatically deleted
   when the child terminates, and thus it is not possible to restart such children.
 
-  If the child process start function returns `{:ok, child}` or `{:ok, child, info}`,
-  the pid is added to the supervisor and this function returns the same value.
+  If the child process start function returns `{:ok, child}` or
+  `{:ok, child, info}`, the pid is added to the supervisor and the function returns
+  the same value.
 
   If the child process start function returns `:ignore`, the pid remains set to
-  `:undefined` and this function returns `{:ok, :undefined}`.
+  `:undefined` and the function returns `{:ok, :undefined}`.
 
-  This function may return an error with an appropriate error tuple if the
-  `child_id` is not found, or if the current process is running or being
-  restarted.
+  This function may error with an appropriate error tuple if the `child_id` is not
+  found, or if the current process is running or being restarted.
 
   If the child process start function returns an error tuple or an erroneous value,
-  or if it fails, this function returns `{:error, error}`.
+  or if it fails, the function returns `{:error, error}`.
 
-  This operation is not supported by `:simple_one_for_one` supervisors.
+  This operation is not supported by `simple_one_for_one` supervisors.
   """
   @spec restart_child(supervisor, Supervisor.Spec.child_id) ::
         {:ok, child} | {:ok, child, term} | {:error, error}
@@ -426,24 +412,23 @@ defmodule Supervisor do
   end
 
   @doc """
-  Returns a list with information about all children of the given supervisor.
+  Returns a list with information about all children.
 
   Note that calling this function when supervising a large number of children
   under low memory conditions can cause an out of memory exception.
 
-  This function returns a list of `{id, child, type, modules}` tuples, where:
+  This function returns a list of tuples containing:
 
     * `id` - as defined in the child specification or `:undefined` in the case
       of a `simple_one_for_one` supervisor
 
-    * `child` - the pid of the corresponding child process, `:restarting` if the
-      process is about to be restarted, or `:undefined` if there is no such
-      process
+    * `child` - the pid of the corresponding child process, the atom
+      `:restarting` if the process is about to be restarted, or `:undefined` if
+      there is no such process
 
-    * `type` - `:worker` or `:supervisor`, as specified by the child specification
-
-    * `modules` - as specified by the child specification
+    * `type` - `:worker` or `:supervisor` as defined in the child specification
 
+    * `modules` - as defined in the child specification
   """
   @spec which_children(supervisor) ::
         [{Supervisor.Spec.child_id | :undefined,
@@ -455,7 +440,7 @@ defmodule Supervisor do
   end
 
   @doc """
-  Returns a map containing count values for the given supervisor.
+  Returns a map containing count values for the supervisor.
 
   The map contains the following keys:
 
@@ -464,11 +449,11 @@ defmodule Supervisor do
     * `:active` - the count of all actively running child processes managed by
       this supervisor
 
-    * `:supervisors` - the count of all supervisors whether or not these
-      child supervisors are still alive
+    * `:supervisors` - the count of all supervisors whether or not the child
+      process is still alive
 
-    * `:workers` - the count of all workers, whether or not these child workers
-      are still alive
+    * `:workers` - the count of all workers, whether or not the child process
+      is still alive
 
   """
   @spec count_children(supervisor) ::
@@ -479,14 +464,15 @@ defmodule Supervisor do
   end
 
   @doc """
-  Stops the given supervisor with the given `reason`.
+  Stops the supervisor with the given `reason`.
 
   It returns `:ok` if the supervisor terminates with the given
-  reason. If it terminates with another reason, the call exits.
+  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(supervisor, reason :: term, timeout) :: :ok
   def stop(supervisor, reason \\ :normal, timeout \\ :infinity) do

lib/elixir/lib/supervisor/default.ex

@@ -1,13 +1,13 @@
 defmodule Supervisor.Default do
   @moduledoc false
+  @behaviour :supervisor
 
   @doc """
   Supervisor callback that simply returns the given args.
 
-  This is the supervisor used by `Supervisor.start_link/2`
-  and others.
+  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,11 +1,11 @@
 defmodule Supervisor.Spec do
   @moduledoc """
-  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
 
@@ -16,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
@@ -37,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 `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
 
@@ -73,31 +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}`
 
   ### 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 `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: Update and provide a digest of strategies once we include DynamicSupervisor.
-
   @typedoc "Supported strategies"
   @type strategy :: :simple_one_for_one | :one_for_one | :one_for_all | :rest_for_one
 
@@ -128,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 `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
 
@@ -144,20 +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: non_neg_integer) :: {:ok, tuple}
-  # TODO: Make it return a tuple of format {:ok, children, opts}
-  # TODO: Deprecate once the new tuple format has been established
   def supervise(children, options) do
     unless strategy = options[:strategy] do
       raise ArgumentError, "expected :strategy option to be given"
@@ -170,7 +169,7 @@ defmodule Supervisor.Spec do
     {:ok, {{strategy, maxR, maxS}, children}}
   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, " <>
@@ -188,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:
@@ -199,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
@@ -212,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:
@@ -223,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
@@ -233,7 +232,6 @@ defmodule Supervisor.Spec do
     child(:supervisor, module, args, options)
   end
 
-  # TODO: Do and expose proper child validation
   defp child(type, module, args, options) do
     id       = Keyword.get(options, :id, module)
     modules  = Keyword.get(options, :modules, modules(module))
@@ -245,7 +243,6 @@ defmodule Supervisor.Spec do
       restart, shutdown, type, modules}
   end
 
-  # TODO: Remove GenEvent when there is no more GenEvent v2.0
   defp modules(GenEvent), do: :dynamic
   defp modules(module),   do: [module]
 end

lib/elixir/lib/system.ex

@@ -1,123 +1,47 @@
 defmodule System do
   @moduledoc """
-  The `System` module provides functions that interact directly
+  The System module provides access to variables used or
+  maintained by the VM and to functions that interact directly
   with the VM or the host system.
-
-  ## Time
-
-  The `System` module also provides functions that work with time,
-  returning different times kept by the system with support for
-  different time units.
-
-  One of the complexities in relying on system times is that they
-  may be adjusted. For example, when you enter and leave daylight
-  saving time, the system clock will be adjusted, often adding
-  or removing one hour. We call such changes "time warps". In
-  order to understand how such changes may be harmful, imagine
-  the following code:
-
-      ## DO NOT DO THIS
-      prev = System.os_time()
-      # ... execute some code ...
-      next = System.os_time()
-      diff = next - prev
-
-  If, while the code is executing, the system clock changes,
-  some code that executed in 1 second may be reported as taking
-  over 1 hour! To address such concerns, the VM provides a
-  monotonic time via `System.monotonic_time/0` which never
-  decreases and does not leap:
-
-      ## DO THIS
-      prev = System.monotonic_time()
-      # ... execute some code ...
-      next = System.monotonic_time()
-      diff = next - prev
-
-  Generally speaking, the VM provides three time measurements:
-
-    * `os_time/0` - the time reported by the OS. This time may be
-      adjusted forwards or backwards in time with no limitation;
-
-    * `system_time/0` - the VM view of the `os_time/0`. The system time and OS
-      time may not match in case of time warps although the VM works towards
-      aligning them. This time is not monotonic (i.e., it may decrease)
-      as its behaviour is configured [by the VM time warp
-      mode](http://www.erlang.org/doc/apps/erts/time_correction.html#Time_Warp_Modes);
-
-    * `monotonic_time/0` - a monotonically increasing time provided
-      by the Erlang VM.
-
-  The time functions in this module work in the `:native` unit
-  (unless specified otherwise), which is OS dependent. Most of
-  the time, all calculations are done in the `:native` unit, to
-  avoid loss of precision, with `convert_time_unit/3` being
-  invoked at the end to convert to a specific time unit like
-  milliseconds or microseconds. See the `t:time_unit/0` type for
-  more information.
-
-  For a more complete rundown on the VM support for different
-  times, see the [chapter on time and time
-  correction](http://www.erlang.org/doc/apps/erts/time_correction.html)
-  in the Erlang docs.
   """
 
-  @typedoc """
-  The time unit to be passed to functions like `monotonic_time/1` and others.
-
-  The `:seconds`, `:milliseconds`, `:microseconds` and `:nanoseconds` time
-  units controls the return value of the functions that accept a time unit.
-
-  A time unit can also be a strictly positive integer. In this case, it
-  represents the "parts per second": the time will be returned in `1 /
-  parts_per_second` seconds. For example, using the `:milliseconds` time unit
-  is equivalent to using `1000` as the time unit (as the time will be returned
-  in 1/1000 seconds - milliseconds).
-
-  Keep in mind the Erlang API will use `:milli_seconds`, `:micro_seconds`
-  and `:nano_seconds` as time units although Elixir normalizes their spelling
-  to match the SI convention.
-  """
-  @type time_unit ::
-    :seconds
-    | :milliseconds
-    | :microseconds
-    | :nanoseconds
-    | pos_integer
-
-  @base_dir     :filename.join(__DIR__, "../../..")
-  @version_file :filename.join(@base_dir, "VERSION")
-
-  defp strip(iodata) do
-    :re.replace(iodata, "^[\s\r\n\t]+|[\s\r\n\t]+$", "", [:global, return: :binary])
+  defp strip_re(iodata, pattern) do
+    :re.replace(iodata, pattern, "", [return: :binary])
   end
 
   defp read_stripped(path) do
     case :file.read_file(path) do
       {:ok, binary} ->
-        strip(binary)
-      _ ->
-        ""
+        strip_re(binary, "^\s+|\s+$")
+      _ -> ""
     end
   end
 
   # Read and strip the version from the VERSION file.
   defmacrop get_version do
-    case read_stripped(@version_file) do
+    case read_stripped(:filename.join(__DIR__, "../../../VERSION")) do
       ""   -> raise RuntimeError, message: "could not read the version number from VERSION"
       data -> data
     end
   end
 
   # Tries to run "git rev-parse --short HEAD". In the case of success returns
-  # the short revision hash. If that fails, returns an empty string.
+  # the short revision hash. If that is not available, tries to read the commit hash
+  # from .git/HEAD. If that fails, returns an empty string.
   defmacrop get_revision do
-    :os.cmd('git rev-parse --short HEAD 2> /dev/null')
-    |> strip
+    dirpath = :filename.join(__DIR__, "../../../.git")
+    case :file.read_file_info(dirpath) do
+      {:ok, _} ->
+        if :os.find_executable('git') do
+          data = :os.cmd('git rev-parse --short HEAD')
+          strip_re(data, "\n")
+        else
+          read_stripped(:filename.join(".git", "HEAD"))
+        end
+      _ -> ""
+    end
   end
 
-  defp revision, do: get_revision
-
   # Get the date at compilation time.
   defmacrop get_date do
     IO.iodata_to_binary :httpd_util.rfc1123_date
@@ -149,26 +73,11 @@ defmodule System do
   @doc """
   Elixir build information.
 
-  Returns a keyword list with Elixir version, Git short revision hash and compilation date.
+  Returns a keyword list with Elixir version, git short revision hash and compilation date.
   """
   @spec build_info() :: map
   def build_info do
-    %{build:    build,
-      date:     get_date,
-      revision: revision,
-      version:  version}
-  end
-
-  # Returns a string of the build info
-  defp build do
-    {:ok, v} = Version.parse(version)
-
-    cond do
-      ([] == v.pre) or ("" == revision) ->
-        version
-      true ->
-        "#{version} (#{revision})"
-    end
+    %{version: version, date: get_date, revision: get_revision}
   end
 
   @doc """
@@ -312,7 +221,7 @@ defmodule System do
   The function must receive the exit status code as an argument.
   """
   def at_exit(fun) when is_function(fun, 1) do
-    :elixir_config.update :at_exit, &[fun | &1]
+    :elixir_config.update :at_exit, &[fun|&1]
   end
 
   @doc """
@@ -326,7 +235,7 @@ defmodule System do
   """
   @spec find_executable(binary) :: binary | nil
   def find_executable(program) when is_binary(program) do
-    case :os.find_executable(String.to_charlist(program)) do
+    case :os.find_executable(String.to_char_list(program)) do
       false -> nil
       other -> List.to_string(other)
     end
@@ -338,7 +247,7 @@ defmodule System do
   Returns a list of all environment variables. Each variable is given as a
   `{name, value}` tuple where both `name` and `value` are strings.
   """
-  @spec get_env() :: %{optional(String.t) => String.t}
+  @spec get_env() :: %{String.t => String.t}
   def get_env do
     Enum.into(:os.getenv, %{}, fn var ->
       var = IO.chardata_to_string var
@@ -356,7 +265,7 @@ defmodule System do
   """
   @spec get_env(binary) :: binary | nil
   def get_env(varname) when is_binary(varname) do
-    case :os.getenv(String.to_charlist(varname)) do
+    case :os.getenv(String.to_char_list(varname)) do
       false -> nil
       other -> List.to_string(other)
     end
@@ -380,7 +289,7 @@ defmodule System do
   """
   @spec put_env(binary, binary) :: :ok
   def put_env(varname, value) when is_binary(varname) and is_binary(value) do
-   :os.putenv String.to_charlist(varname), String.to_charlist(value)
+   :os.putenv String.to_char_list(varname), String.to_char_list(value)
    :ok
   end
 
@@ -402,7 +311,7 @@ defmodule System do
   """
   @spec delete_env(String.t) :: :ok
   def delete_env(varname) do
-    :os.unsetenv(String.to_charlist(varname))
+    :os.unsetenv(String.to_char_list(varname))
     :ok
   end
 
@@ -455,7 +364,7 @@ defmodule System do
   end
 
   def halt(status) when is_binary(status) do
-    :erlang.halt(String.to_charlist(status))
+    :erlang.halt(String.to_char_list(status))
   end
 
   @doc ~S"""
@@ -464,13 +373,10 @@ defmodule System do
   `command` is expected to be an executable available in PATH
   unless an absolute path is given.
 
-  `args` must be a list of binaries which the executable will receive
-  as its arguments as is. This means that:
-
-    * environment variables will not be interpolated
-    * wildcard expansion will not happen (unless `Path.wildcard/2` is used
-      explicitly)
-    * arguments do not need to be escaped or quoted for shell safety
+  `args` must be a list of strings which are not expanded
+  in any way. For example, this means wildcard expansion will
+  not happen unless `Path.wildcard/2` is used. On Windows though,
+  wildcard expansion is up to the program.
 
   This function returns a tuple containing the collected result
   and the command exit status.
@@ -535,7 +441,7 @@ defmodule System do
   @spec cmd(binary, [binary], Keyword.t) ::
         {Collectable.t, exit_status :: non_neg_integer}
   def cmd(command, args, opts \\ []) when is_binary(command) and is_list(args) do
-    cmd = String.to_charlist(command)
+    cmd = String.to_char_list(command)
 
     cmd =
       if Path.type(cmd) == :absolute do
@@ -567,28 +473,28 @@ defmodule System do
     end
   end
 
-  defp cmd_opts([{:into, any} | t], opts, _into),
+  defp cmd_opts([{:into, any}|t], opts, _into),
     do: cmd_opts(t, opts, any)
 
-  defp cmd_opts([{:cd, bin} | t], opts, into) when is_binary(bin),
-    do: cmd_opts(t, [{:cd, bin} | opts], into)
+  defp cmd_opts([{:cd, bin}|t], opts, into) when is_binary(bin),
+    do: cmd_opts(t, [{:cd, bin}|opts], into)
 
-  defp cmd_opts([{:arg0, bin} | t], opts, into) when is_binary(bin),
-    do: cmd_opts(t, [{:arg0, bin} | opts], into)
+  defp cmd_opts([{:arg0, bin}|t], opts, into) when is_binary(bin),
+    do: cmd_opts(t, [{:arg0, bin}|opts], into)
 
-  defp cmd_opts([{:stderr_to_stdout, true} | t], opts, into),
-    do: cmd_opts(t, [:stderr_to_stdout | opts], into)
+  defp cmd_opts([{:stderr_to_stdout, true}|t], opts, into),
+    do: cmd_opts(t, [:stderr_to_stdout|opts], into)
 
-  defp cmd_opts([{:stderr_to_stdout, false} | t], opts, into),
+  defp cmd_opts([{:stderr_to_stdout, false}|t], opts, into),
     do: cmd_opts(t, opts, into)
 
-  defp cmd_opts([{:parallelism, bool} | t], opts, into) when is_boolean(bool),
-    do: cmd_opts(t, [{:parallelism, bool} | opts], into)
+  defp cmd_opts([{:parallelism, bool}|t], opts, into) when is_boolean(bool),
+    do: cmd_opts(t, [{:parallelism, bool}|opts], into)
 
-  defp cmd_opts([{:env, enum} | t], opts, into),
-    do: cmd_opts(t, [{:env, validate_env(enum)} | opts], into)
+  defp cmd_opts([{:env, enum}|t], opts, into),
+    do: cmd_opts(t, [{:env, validate_env(enum)}|opts], into)
 
-  defp cmd_opts([{key, val} | _], _opts, _into),
+  defp cmd_opts([{key, val}|_], _opts, _into),
     do: raise(ArgumentError, "invalid option #{inspect key} with value #{inspect val}")
 
   defp cmd_opts([], opts, into),
@@ -597,9 +503,9 @@ defmodule System do
   defp validate_env(enum) do
     Enum.map enum, fn
       {k, nil} ->
-        {String.to_charlist(k), false}
+        {String.to_char_list(k), false}
       {k, v} ->
-        {String.to_charlist(k), String.to_charlist(v)}
+        {String.to_char_list(k), String.to_char_list(v)}
       other ->
         raise ArgumentError, "invalid environment key-value #{inspect other}"
     end
@@ -608,8 +514,12 @@ defmodule System do
   @doc """
   Returns the current monotonic time in the `:native` time unit.
 
-  This time is monotonically increasing and starts in an unspecified
-  point in time.
+  This time is monotonically increasing and starts in an unspecified point in
+  time.
+
+  For more information, see the [chapter on time and time
+  correction](http://www.erlang.org/doc/apps/erts/time_correction.html) in the
+  Erlang docs.
 
   Inlined by the compiler into `:erlang.monotonic_time/0`.
   """
@@ -621,20 +531,23 @@ defmodule System do
   @doc """
   Returns the current monotonic time in the given time unit.
 
-  This time is monotonically increasing and starts in an unspecified
-  point in time.
+  For more information, see the [chapter on time and time
+  correction](http://www.erlang.org/doc/apps/erts/time_correction.html) in the
+  Erlang docs.
+
+  Inlined by the compiler into `:erlang.monotonic_time/1`.
   """
-  @spec monotonic_time(time_unit) :: integer
+  @spec monotonic_time(:erlang.time_unit) :: integer
   def monotonic_time(unit) do
-    :erlang.monotonic_time(normalize_time_unit(unit))
+    :erlang.monotonic_time(unit)
   end
 
   @doc """
   Returns the current system time in the `:native` time unit.
 
-  It is the VM view of the `os_time/0`. They may not match in
-  case of time warps although the VM works towards aligning
-  them. This time is not monotonic.
+  For more information, see the [chapter on time and time
+  correction](http://www.erlang.org/doc/apps/erts/time_correction.html) in the
+  Erlang docs.
 
   Inlined by the compiler into `:erlang.system_time/0`.
   """
@@ -646,36 +559,31 @@ defmodule System do
   @doc """
   Returns the current system time in the given time unit.
 
-  It is the VM view of the `os_time/0`. They may not match in
-  case of time warps although the VM works towards aligning
-  them. This time is not monotonic.
+  For more information, see the [chapter on time and time
+  correction](http://www.erlang.org/doc/apps/erts/time_correction.html) in the
+  Erlang docs.
+
+  Inlined by the compiler into `:erlang.system_time/1`.
   """
-  @spec system_time(time_unit) :: integer
+  @spec system_time(:erlang.time_unit) :: integer
   def system_time(unit) do
-    :erlang.system_time(normalize_time_unit(unit))
+    :erlang.system_time(unit)
   end
 
   @doc """
-  Converts `time` from time unit `from_unit` to time unit `to_unit`.
+  Converts `time` from time unit `from_unit` to time unit `to_unit`. The result
+  is rounded via the floor function.
 
-  The result is rounded via the floor function.
-
-  `convert_time_unit/3` accepts an additional time unit (other than the
-  ones in the `time_unit` type) called `:native`. `:native` is the time
-  unit used by the Erlang runtime system. It's determined when the runtime
-  starts and stays the same until the runtime is stopped. To determine what
-  the `:native` unit amounts to in a system, you can call this function to
-  convert 1 second to the `:native` time unit (i.e.,
-  `System.convert_time_unit(1, :seconds, :native)`).
+  Inlined by the compiler into `:erlang.convert_time_unit/3`.
   """
-  @spec convert_time_unit(integer, time_unit | :native, time_unit | :native) :: integer
+  @spec convert_time_unit(integer, :erlang.time_unit, :erlang.time_unit) :: integer
   def convert_time_unit(time, from_unit, to_unit) do
-    :erlang.convert_time_unit(time, normalize_time_unit(from_unit), normalize_time_unit(to_unit))
+    :erlang.convert_time_unit(time, from_unit, to_unit)
   end
 
   @doc """
-  Returns the current time offset between the Erlang VM monotonic
-  time and the Erlang VM system time.
+  Returns the current time offset between the Erlang monotonic time and the
+  Erlang system time.
 
   The result is returned in the `:native` time unit.
 
@@ -689,67 +597,22 @@ defmodule System do
   end
 
   @doc """
-  Returns the current time offset between the Erlang VM monotonic
-  time and the Erlang VM system time.
+  Returns the current time offset between the Erlang monotonic time and the
+  Erlang system time.
 
-  The result is returned in the given time unit `unit`. The returned
-  offset, added to an Erlang monotonic time (e.g., obtained with
-  `monotonic_time/1`), gives the Erlang system time that corresponds
-  to that monotonic time.
+  The result is returned in the given time unit `unit`. The returned offset,
+  added to an Erlang monotonic time (e.g., obtained with `monotonic_time/1`),
+  gives the Erlang system time that corresponds to that monotonic time.
+
+  For more information, see the [chapter on time and time
+  correction](http://www.erlang.org/doc/apps/erts/time_correction.html) in the
+  Erlang docs.
+
+  Inlined by the compiler into `:erlang.time_offset/1`.
   """
-  @spec time_offset(time_unit) :: integer
+  @spec time_offset(:erlang.time_unit) :: integer
   def time_offset(unit) do
-    :erlang.time_offset(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Returns the current OS time.
-
-  The result is returned in the `:native` time unit.
-
-  This time may be adjusted forwards or backwards in time
-  with no limitation and is not monotonic.
-
-  Inlined by the compiler into `:os.system_time/0`.
-  """
-  @spec os_time() :: integer
-  def os_time do
-    :os.system_time()
-  end
-
-  @doc """
-  Returns the current OS time in the given time `unit`.
-
-  This time may be adjusted forwards or backwards in time
-  with no limitation and is not monotonic.
-  """
-  @spec os_time(time_unit) :: integer
-  def os_time(unit) do
-    :os.system_time(normalize_time_unit(unit))
-  end
-
-  @doc """
-  Returns the OTP release number.
-  """
-  @spec otp_release :: String.t
-  def otp_release do
-    :erlang.list_to_binary :erlang.system_info(:otp_release)
-  end
-
-  @doc """
-  Returns the number of schedulers in the VM.
-  """
-  @spec schedulers :: pos_integer
-  def schedulers do
-    :erlang.system_info(:schedulers)
-  end
-
-  @doc """
-  Returns the number of schedulers online in the VM.
-  """
-  @spec schedulers_online :: pos_integer
-  def schedulers_online do
-    :erlang.system_info(:schedulers_online)
+    :erlang.time_offset(unit)
   end
 
   @doc """
@@ -760,7 +623,7 @@ defmodule System do
   will never return the same integer more than once on the current runtime
   instance.
 
-  If `modifiers` is `[]`, then a unique integer (that can be positive or negative) is returned.
+  If `modifiers` is `[]`, then an unique integer (that can be positive or negative) is returned.
   Other modifiers can be passed to change the properties of the returned integer:
 
     * `:positive` - the returned integer is guaranteed to be positive.
@@ -779,30 +642,4 @@ defmodule System do
   def unique_integer(modifiers \\ []) do
     :erlang.unique_integer(modifiers)
   end
-
-  defp normalize_time_unit(:native),
-    do: :native
-  defp normalize_time_unit(:seconds),
-    do: :seconds
-  defp normalize_time_unit(:milliseconds),
-    do: :milli_seconds
-  defp normalize_time_unit(:microseconds),
-    do: :micro_seconds
-  defp normalize_time_unit(:nanoseconds),
-    do: :nano_seconds
-  defp normalize_time_unit(unit) when is_integer(unit) and unit > 0,
-    do: unit
-
-  # TODO: Warn on Elixir 1.5
-  defp normalize_time_unit(erlang_unit)
-      when erlang_unit in [:milli_seconds, :micro_seconds, :nano_seconds] do
-    erlang_unit
-  end
-
-  defp normalize_time_unit(other) do
-    raise ArgumentError,
-      "unsupported time unit. Expected :seconds, :milliseconds, " <>
-      ":microseconds, :nanoseconds, or a positive integer, " <>
-      "got #{inspect other}"
-  end
 end

lib/elixir/lib/task.ex

@@ -3,7 +3,7 @@ defmodule Task do
   Conveniences for spawning and awaiting tasks.
 
   Tasks are processes meant to execute one particular
-  action throughout their lifetime, often with little or no
+  action throughout their life-cycle, often with little or no
   communication with other processes. The most common use case
   for tasks is to convert sequential code into concurrent code
   by computing a value asynchronously:
@@ -12,51 +12,51 @@ defmodule Task do
       res  = do_some_other_work()
       res + Task.await(task)
 
-  Tasks spawned with `async` can be awaited on by their caller
+  Tasks spawned with `async` can be waited on by their caller
   process (and only their caller) as shown in the example above.
   They are implemented by spawning a process that sends a message
   to the caller once the given computation is performed.
 
   Besides `async/1` and `await/2`, tasks can also be
-  started as part of a supervision tree and dynamically spawned
-  on remote nodes. We will explore all three scenarios next.
+  started as part of supervision tree and dynamically spawned
+  in remote nodes. We will explore all three scenarios next.
 
   ## async and await
 
-  One of the common uses of tasks is to convert sequential code
+  One of the common use of tasks is to convert sequential code
   into concurrent code with `Task.async/1` while keeping its semantics.
   When invoked, a new process will be created, linked and monitored
   by the caller. Once the task action finishes, a message will be sent
   to the caller with the result.
 
   `Task.await/2` is used to read the message sent by the task.
+  `await` will check the monitor setup by the call to `async/1` to
+  verify if the process exited for any abnormal reason (or in case
+  exits are being trapped by the caller).
 
-  There are two important things to consider when using `async`:
+  There are two important things to consider when using async:
 
     1. If you are using async tasks, you must await a reply
        as they are *always* sent. If you are not expecting a reply,
-       consider using `Task.start_link/1` detailed below.
+       consider using `Task.start_link/1` detailed below
 
     2. async tasks link the caller and the spawned process. This
        means that, if the caller crashes, the task will crash
-       too and vice-versa. This is on purpose: if the process
+       too and vice-versa. This is on purpose, if the process
        meant to receive the result no longer exists, there is
-       no purpose in completing the computation.
-
-       If this is not desired, use `Task.start/1` or consider starting
-       the task under a `Task.Supervisor` using `async_nolink` or
-       `start_child`.
+       no purpose in completing computation of the result. If this
+       is not desired, consider using `Task.start_link/1` as well
 
   `Task.yield/2` is an alternative to `await/2` where the caller will
   temporarily block, waiting until the task replies or crashes. If the
-  result does not arrive within the timeout, it can be called again at a
+  result does not arrive within the timeout it can be called again at a
   later moment. This allows checking for the result of a task multiple
-  times. If a reply does not arrive within the desired time,
-  `Task.shutdown/2` can be used to stop the task.
+  times or to handle a timeout. If a reply does not arrive within the
+  desired time, `Task.shutdown/2` can be used to stop the task.
 
   ## Supervised tasks
 
-  It is also possible to spawn a task under a supervisor
+  It is also possible to spawn a task inside a supervision tree
   with `start_link/1` and `start_link/3`:
 
       Task.start_link(fn -> IO.puts "ok" end)
@@ -70,12 +70,12 @@ defmodule Task do
       ]
 
   Since these tasks are supervised and not directly linked to
-  the caller, they cannot be awaited on. Note `start_link/1`,
+  the caller, they cannot be waited on. Note `start_link/1`,
   unlike `async/1`, returns `{:ok, pid}` (which is
   the result expected by supervision trees).
 
   By default, most supervision strategies will try to restart
-  a worker after it exits regardless of the reason. If you design the
+  a worker after it exits regardless of reason. If you design the
   task to terminate normally (as in the example with `IO.puts/2` above),
   consider passing `restart: :transient` in the options to `worker/3`.
 
@@ -113,17 +113,18 @@ defmodule Task do
         # Do something
       end) |> Task.await()
 
-  Finally, check `Task.Supervisor` for other supported operations.
+  Finally, check `Task.Supervisor` for other operations supported by the
+  Task supervisor.
 
   ## Distributed tasks
 
-  Since Elixir provides a Task supervisor, it is easy to use one
-  to dynamically spawn tasks across nodes:
+  Since Elixir provides a Task supervisor, it is easy to use a task
+  supervisor to dynamically spawn tasks across nodes:
 
-      # On the remote node
+      # In the remote node
       Task.Supervisor.start_link(name: MyApp.DistSupervisor)
 
-      # On the client
+      # In the client
       Task.Supervisor.async({MyApp.DistSupervisor, :remote@local},
                             MyMod, :my_fun, [arg1, arg2, arg3])
 
@@ -132,16 +133,16 @@ defmodule Task do
   works with anonymous functions. That's because anonymous functions expect
   the same module version to exist on all involved nodes. Check the `Agent` module
   documentation for more information on distributed processes as the limitations
-  described there apply to the whole ecosystem.
+  described in the agents documentation apply to the whole ecosystem.
   """
 
   @doc """
   The Task struct.
 
-  It contains these fields:
+  It contains two fields:
 
-    * `:pid` - the PID of the task process; `nil` if the task does
-      not use a task process
+    * `:pid` - the process reference of the task process; `nil` if the task does
+      not use a task process.
 
     * `:ref` - the task monitor reference
 
@@ -193,7 +194,7 @@ defmodule Task do
   end
 
   @doc """
-  Starts a task that must be awaited on.
+  Starts a task that can be awaited on.
 
   This function spawns a process that is linked to and monitored
   by the caller process. A `Task` struct is returned containing
@@ -202,7 +203,10 @@ defmodule Task do
   Read the `Task` module documentation for more info on general
   usage of `async/1` and `async/3`.
 
-  See also `async/3`.
+  ## Task's message format
+
+  The reply sent by the task will be in the format `{ref, msg}`,
+  where `ref` is the monitoring reference held by the task.
   """
   @spec async(fun) :: t
   def async(fun) do
@@ -240,10 +244,10 @@ defmodule Task do
   As before, if `heavy_fun/0` fails, the whole computation will
   fail, including the parent process. If you don't want the task
   to fail then you must change the `heavy_fun/0` code in the
-  same way you would achieve it if you didn't have the async call.
-  For example, to either return `{:ok, val} | :error` results or,
+  same way you would if you didn't have the async call. For
+  example to either return `{:ok, val} | :error` results or,
   in more extreme cases, by using `try/rescue`. In other words,
-  an asynchronous task should be thought of as an extension of a
+  an asynchronous task should be considered an extension of a
   process rather than a mechanism to isolate it from all errors.
 
   If you don't want to link the caller to the task, then you
@@ -252,15 +256,11 @@ defmodule Task do
 
   In any case, avoid any of the following:
 
-    * Setting `:trap_exit` to `true` - trapping exits should be
+    * Setting `:trap_exit` to true - trapping exists should be
       used only in special circumstances as it would make your
       process immune to not only exits from the task but from
       any other processes.
 
-      Moreover, even when trapping exists, calling `await` will
-      still exit if the task has terminated without sending its
-      result back.
-
     * Unlinking the task process started with `async`/`await`.
       If you unlink the processes and the task does not belong
       to any supervisor, you may leave dangling tasks in case
@@ -268,9 +268,8 @@ defmodule Task do
 
   ## Message format
 
-  The reply sent by the task will be in the format `{ref, result}`,
-  where `ref` is the monitor reference held by the task struct
-  and `result` is the return value of the task function.
+  The reply sent by the task will be in the format `{ref, msg}`,
+  where `ref` is the monitoring reference held by the task.
   """
   @spec async(module, atom, [term]) :: t
   def async(mod, fun, args) do
@@ -297,33 +296,34 @@ defmodule Task do
   of `5000`. In case the task process dies, this function will
   exit with the same reason as the task.
 
-  If the timeout is exceeded, `await` will exit; however,
+  If the timeout is exceeded, `await` will exit, however,
   the task will continue to run. When the calling process exits, its
   exit signal will terminate the task if it is not trapping exits.
 
   This function assumes the task's monitor is still active or the monitor's
   `:DOWN` message is in the message queue. If it has been demonitored, or the
-  message already received, this function will wait for the duration of the
+  message already received, this function may wait for the duration of the
   timeout awaiting the message.
 
-  This function can only be called once for any given task. If you want
-  to be able to check multiple times if a long-running task has finished
-  its computation, use `yield/2` instead.
-
-  ## Compatibility with OTP behaviours
-
-  It is not recommended to `await` a long-running task inside an OTP
-  behaviour such as `GenServer`. Instead, you should match on the message
-  coming from a task inside your `handle_info` callback.
+  This function will always exit and demonitor if the task crashes or if
+  it times out, so the task can not be used again. To explicitly handle
+  the timeout or the crash, use `yield/2` instead.
   """
   @spec await(t, timeout) :: term | no_return
   def await(task, timeout \\ 5000)
 
-  def await(%Task{owner: owner} = task, _) when owner != self() do
+  # TODO: Remove nil check in Elixir 1.3
+  def await(%Task{owner: owner}=task, _) when owner != nil and owner != self() do
     raise ArgumentError, invalid_owner_error(task)
   end
 
-  def await(%Task{ref: ref} = task, timeout) do
+  def await(%Task{ref: ref, owner: owner}=task, timeout) do
+    if is_nil(owner) do
+      IO.write :stderr, "warning: a Task was created with the :owner field no set, " <>
+                        "please ensure the owner field is correctly set to self()\n" <>
+                        Exception.format_stacktrace
+    end
+
     receive do
       {^ref, reply} ->
         Process.demonitor(ref, [:flush])
@@ -337,14 +337,25 @@ defmodule Task do
     end
   end
 
-  @doc false
-  # TODO: Remove on 2.0
-  def find(tasks, msg) do
-    IO.warn "Task.find/2 is deprecated, please match on the message directly"
-    do_find(tasks, msg)
-  end
+  @doc """
+  Receives a group of tasks and a message and finds
+  a task that matches the given message.
 
-  defp do_find(tasks, {ref, reply}) when is_reference(ref) do
+  This function returns a tuple with the returned value
+  in case the message matches a task that exited with
+  success alongside the matching task. It returns `nil`
+  if no task was found. It exits if the task has failed.
+
+  This function is useful in situations where multiple
+  tasks are spawned and their results are collected
+  later on. For example, a `GenServer` can spawn tasks,
+  store the tasks in a list and later use `Task.find/2`
+  to see if incoming messages are from any of the tasks.
+  """
+  @spec find([t], any) :: {term, t} | nil | no_return
+  def find(tasks, msg)
+
+  def find(tasks, {ref, reply}) when is_reference(ref) do
     Enum.find_value tasks, fn
       %Task{ref: ^ref} = task ->
         Process.demonitor(ref, [:flush])
@@ -354,49 +365,51 @@ defmodule Task do
     end
   end
 
-  defp do_find(tasks, {:DOWN, ref, _, proc, reason} = msg) when is_reference(ref) do
+  def find(tasks, {:DOWN, ref, _, proc, reason} = msg) when is_reference(ref) do
     find = fn %Task{ref: task_ref} -> task_ref == ref end
     if Enum.find(tasks, find) do
       exit({reason(reason, proc), {__MODULE__, :find, [tasks, msg]}})
     end
   end
 
-  defp do_find(_tasks, _msg) do
+  def find(_tasks, _msg) do
     nil
   end
 
   @doc """
-  Temporarily blocks the current process waiting for a task reply.
+  Yields for a task reply in the given time interval.
 
-  Returns `{:ok, reply}` if the reply is received, `nil` if
-  no reply has arrived, or `{:exit, reason}` if the task has already
-  exited. Keep in mind that normally a task failure also causes
-  the process owning the task to exit. Therefore this function can
-  return `{:exit, reason}` only if
-
-    * the task process exited with the reason `:normal`
-    * it isn't linked to the caller
-    * the caller is trapping exits
+  Returns `{:ok, reply}` if the reply is received, `{:exit, reason}`
+  if the task exited or `nil` if no reply arrived.
 
   A timeout, in milliseconds, can be given with default value
-  of `5000`. If the time runs out before a message from
-  the task is received, this function will return `nil`
+  of `5000`. In case of the timeout, this function will return `nil`
   and the monitor will remain active. Therefore `yield/2` can be
   called multiple times on the same task.
 
+  In case the task process dies, this function will exit with the
+  same reason as the task.
+
   This function assumes the task's monitor is still active or the
   monitor's `:DOWN` message is in the message queue. If it has been
-  demonitored or the message already received, this function will wait
+  demonitored, or the message already received, this function waits
   for the duration of the timeout awaiting the message.
   """
   @spec yield(t, timeout) :: {:ok, term} | {:exit, term} | nil
   def yield(task, timeout \\ 5_000)
 
-  def yield(%Task{owner: owner} = task, _) when owner != self() do
+  # TODO: Remove nil check in Elixir 1.3
+  def yield(%Task{owner: owner} = task, _) when owner != nil and owner != self() do
     raise ArgumentError, invalid_owner_error(task)
   end
 
-  def yield(%Task{ref: ref} = task, timeout) do
+  def yield(%Task{ref: ref, owner: owner} = task, timeout) do
+    if is_nil(owner) do
+      IO.write :stderr, "warning: a Task was created with the :owner field no set, " <>
+                        "please ensure the owner field is correctly set to self()\n" <>
+                        Exception.format_stacktrace
+    end
+
     receive do
       {^ref, reply} ->
         Process.demonitor(ref, [:flush])
@@ -414,19 +427,14 @@ defmodule Task do
   @doc """
   Yields to multiple tasks in the given time interval.
 
-  This function receives a list of tasks and waits for their
-  replies in the given time interval. It returns a list
-  of tuples of two elements, with the task as the first element
-  and the yielded result as the second.
+  This function receives a list of tasks and await for their
+  replies at once in the given time interval. It returns a list
+  of tuples of two elements, with tasks as the first element and
+  the `yield` result as the second.
 
-  Similarly to `yield/2`, each task's result will be
-
-    * `{:ok, term}` if the task has successfully reported its
-      result back in the given time interval
-    * `{:exit, reason}` if the task has died
-    * `nil` if the task keeps running past the timeout
-
-  Check `yield/2` for more information.
+  Similar to `yield/2`, if the task replied in the given interval,
+  it will return `{:ok, term}`, `{:exit, reason}`if it crashed or
+  `nil` if it timed out. Check `yield/2` for more information.
 
   ## Example
 
@@ -434,7 +442,6 @@ defmodule Task do
   and retrieve the results received in a given timeframe.
   If we combine it with `Task.shutdown/2`, it allows us to gather
   those results and cancel the tasks that have not replied in time.
-
   Let's see an example.
 
       tasks =
@@ -462,8 +469,8 @@ defmodule Task do
   up to 10 seconds and return the amount of seconds they slept.
   If you execute the code all at once, you should see 1 up to 5
   printed, as those were the tasks that have replied in the
-  given time. All other tasks will have been shut down using
-  the `Task.shutdown/2` call.
+  given time. All other tasks will have been shutdown, according
+  to the `Task.shutdown/2` call.
   """
   @spec yield_many([t], timeout) :: [{t, {:ok, term} | {:exit, term} | nil}]
   def yield_many(tasks, timeout \\ 5000) do
@@ -480,7 +487,7 @@ defmodule Task do
     end
   end
 
-  defp yield_many([%Task{ref: ref, owner: owner}=task | rest], timeout_ref, timeout) do
+  defp yield_many([%Task{ref: ref, owner: owner}=task|rest], timeout_ref, timeout) do
     if owner != self() do
       raise ArgumentError, invalid_owner_error(task)
     end
@@ -488,20 +495,20 @@ defmodule Task do
     receive do
       {^ref, reply} ->
         Process.demonitor(ref, [:flush])
-        [{task, {:ok, reply}} | yield_many(rest, timeout_ref, timeout)]
+        [{task, {:ok, reply}}|yield_many(rest, timeout_ref, timeout)]
 
       {:DOWN, ^ref, _, proc, :noconnection} ->
         throw({:noconnection, reason(:noconnection, proc)})
 
       {:DOWN, ^ref, _, _, reason} ->
-        [{task, {:exit, reason}} | yield_many(rest, timeout_ref, timeout)]
+        [{task, {:exit, reason}}|yield_many(rest, timeout_ref, timeout)]
 
       ^timeout_ref ->
-        [{task, nil} | yield_many(rest, timeout_ref, 0)]
+        [{task, nil}|yield_many(rest, timeout_ref, 0)]
 
     after
       timeout ->
-        [{task, nil} | yield_many(rest, timeout_ref, 0)]
+        [{task, nil}|yield_many(rest, timeout_ref, 0)]
 
     end
   end
@@ -511,23 +518,23 @@ defmodule Task do
   end
 
   @doc """
-  Unlinks and shuts down the task, and then checks for a reply.
+  Unlinks and shutdowns the task, and then checks for a reply.
 
   Returns `{:ok, reply}` if the reply is received while shutting down the task,
-  `{:exit, reason}` if the task died, otherwise `nil`.
+  `{:exit, reason}` if the task exited abornormally, otherwise `nil`.
 
   The shutdown method is either a timeout or `:brutal_kill`. In case
   of a `timeout`, a `:shutdown` exit signal is sent to the task process
-  and if it does not exit within the timeout, it is killed. With `:brutal_kill`
-  the task is killed straight away. In case the task terminates abnormally
-  (possibly killed by another process), this function will exit with the same reason.
+  and if it does not exit within the timeout it is killed. With `:brutal_kill`
+  the task is killed straight away. In case the task exits abnormally, or a 
+  timeout shutdown kills the task, this function will exit with the same reason.
 
   It is not required to call this function when terminating the caller, unless
-  exiting with reason `:normal` or if the task is trapping exits. If the caller is
-  exiting with a reason other than `:normal` and the task is not trapping exits, the
+  exiting with reason `:normal` or the task is trapping exits. If the caller is
+  exiting with a reason other than `:normal` and the task is not trapping exits the
   caller's exit signal will stop the task. The caller can exit with reason
-  `:shutdown` to shutdown all of its linked processes, including tasks, that
-  are not trapping exits without generating any log messages.
+  `:shutdown` to shutdown linked processes, such as tasks, that are not trapping
+  exits without generating any log messages.
 
   This function assumes the task's monitor is still active or the monitor's
   `:DOWN` message is in the message queue. If it has been demonitored, or the
@@ -540,11 +547,18 @@ defmodule Task do
     raise ArgumentError, "task #{inspect task} does not have an associated task process"
   end
 
-  def shutdown(%Task{owner: owner} = task, _) when owner != self() do
+  # TODO: Remove nil check in Elixir 1.3
+  def shutdown(%Task{owner: owner} = task, _) when owner != nil and owner != self() do
     raise ArgumentError, invalid_owner_error(task)
   end
 
-  def shutdown(%Task{pid: pid} = task, :brutal_kill) do
+  def shutdown(%Task{pid: pid, owner: owner} = task, :brutal_kill) do
+    if is_nil(owner) do
+      IO.write :stderr, "warning: a Task was created with the :owner field no set, " <>
+                        "please ensure the owner field is correctly set to self()\n" <>
+                        Exception.format_stacktrace
+    end
+
     exit(pid, :kill)
 
     case shutdown_receive(task, :brutal_kill, :infinity) do

lib/elixir/lib/task/supervised.ex

@@ -23,12 +23,7 @@ defmodule Task.Supervised do
     initial_call(mfa)
     case link do
       :link ->
-        try do
-          Process.link(caller)
-        catch
-          :error, :noproc ->
-            exit({:shutdown, :noproc})
-        end
+        Process.link(caller)
         reply(caller, nil, @ref_timeout, info, mfa)
       :monitor ->
         mref = Process.monitor(caller)
@@ -44,7 +39,7 @@ defmodule Task.Supervised do
         _ = if mref, do: Process.demonitor(mref, [:flush])
         send caller, {ref, do_apply(info, mfa)}
       {:DOWN, ^mref, _, _, reason} when is_reference(mref) ->
-        exit({:shutdown, reason})
+        exit(reason)
     after
       # There is a race condition on this operation when working across
       # node that manifests if a "Task.Supervisor.async/2" call is made

lib/elixir/lib/task/supervisor.ex

@@ -26,8 +26,8 @@ defmodule Task.Supervisor do
 
   * `:restart` - the restart strategy, may be `:temporary` (the default),
     `:transient` or `:permanent`. Check `Supervisor.Spec` for more info.
-    Defaults to `:temporary` so tasks aren't automatically restarted when
-    they complete nor in case of crashes;
+    Defaults to `:temporary` as most tasks can't be effectively restarted after
+    a crash;
 
   * `:shutdown` - `:brutal_kill` if the tasks must be killed directly on shutdown
     or an integer indicating the timeout value, defaults to 5000 milliseconds;
@@ -65,7 +65,13 @@ defmodule Task.Supervisor do
   """
   @spec async(Supervisor.supervisor, module, atom, [term]) :: Task.t
   def async(supervisor, module, fun, args) do
-    do_async(supervisor, module, fun, args, :link)
+    owner = self()
+    args = [owner, :link, get_info(owner), {module, fun, args}]
+    {:ok, pid} = Supervisor.start_child(supervisor, args)
+    Process.link(pid)
+    ref = Process.monitor(pid)
+    send pid, {owner, ref}
+    %Task{pid: pid, ref: ref, owner: owner}
   end
 
   @doc """
@@ -74,21 +80,6 @@ defmodule Task.Supervisor do
   The `supervisor` must be a reference as defined in `Task.Supervisor`.
   The task won't be linked to the caller, see `Task.async/3` for
   more information.
-
-  ## Compatibility with OTP behaviours
-
-  If you create a task using `async_nolink` inside an OTP behaviour
-  like `GenServer`, you should match on the message coming from the
-  task inside your `handle_info` callback.
-
-  The reply sent by the task will be in the format `{ref, result}`,
-  where `ref` is the monitor reference held by the task struct
-  and `result` is the return value of the task function.
-
-  Keep in mind that, regardless of how the task created with `async_nolink`
-  terminates, the caller's process will always receive a `:DOWN` message
-  with the same `ref` value that is held by the task struct. If the task
-  terminates normally, the reason in the `:DOWN` message will be `:normal`.
   """
   @spec async_nolink(Supervisor.supervisor, fun) :: Task.t
   def async_nolink(supervisor, fun) do
@@ -104,7 +95,12 @@ defmodule Task.Supervisor do
   """
   @spec async_nolink(Supervisor.supervisor, module, atom, [term]) :: Task.t
   def async_nolink(supervisor, module, fun, args) do
-    do_async(supervisor, module, fun, args, :monitor)
+    owner = self()
+    args = [owner, :monitor, get_info(owner), {module, fun, args}]
+    {:ok, pid} = Supervisor.start_child(supervisor, args)
+    ref = Process.monitor(pid)
+    send pid, {owner, ref}
+    %Task{pid: pid, ref: ref, owner: owner}
   end
 
   @doc """
@@ -120,11 +116,11 @@ defmodule Task.Supervisor do
   """
   @spec children(Supervisor.supervisor) :: [pid]
   def children(supervisor) do
-    for {_, pid, _, _} <- Supervisor.which_children(supervisor), is_pid(pid), do: pid
+    Supervisor.which_children(supervisor) |> Enum.map(&elem(&1, 1))
   end
 
   @doc """
-  Starts a task as a child of the given `supervisor`.
+  Starts a task as child of the given `supervisor`.
 
   Note that the spawned process is not linked to the caller, but
   only to the supervisor. This command is useful in case the
@@ -137,7 +133,7 @@ defmodule Task.Supervisor do
   end
 
   @doc """
-  Starts a task as a child of the given `supervisor`.
+  Starts a task as child of the given `supervisor`.
 
   Similar to `start_child/2` except the task is specified
   by the given `module`, `fun` and `args`.
@@ -154,14 +150,4 @@ defmodule Task.Supervisor do
        {:registered_name, name} -> name
      end}
   end
-
-  defp do_async(supervisor, module, fun, args, link_type) do
-    owner = self()
-    args = [owner, link_type, get_info(owner), {module, fun, args}]
-    {:ok, pid} = Supervisor.start_child(supervisor, args)
-    if link_type == :link, do: Process.link(pid)
-    ref = Process.monitor(pid)
-    send pid, {owner, ref}
-    %Task{pid: pid, ref: ref, owner: owner}
-  end
 end

lib/elixir/lib/uri.ex

@@ -1,35 +1,21 @@
 defmodule URI do
   @moduledoc """
-  Utilities for working with URIs.
-
-  This module provides functions for working with URIs (for example, parsing
-  URIs or encoding query strings). For reference, most of the functions in this
-  module refer to [RFC 3986](https://tools.ietf.org/html/rfc3986).
+  Utilities for working with and creating URIs.
   """
 
   defstruct scheme: nil, path: nil, query: nil,
             fragment: nil, authority: nil,
             userinfo: nil, host: nil, port: nil
 
-  @type t :: %__MODULE__{
-    scheme: nil | binary,
-    path: nil | binary,
-    query: nil | binary,
-    fragment: nil | binary,
-    authority: nil | binary,
-    userinfo: nil | binary,
-    host: nil | binary,
-    port: nil | :inet.port_number,
-  }
+  @type t :: %__MODULE__{}
 
   import Bitwise
 
   @doc """
   Returns the default port for a given scheme.
 
-  If the scheme is unknown to the `URI` module, this function returns
-  `nil`. The default port for any scheme can be configured globally
-  via `default_port/2`.
+  If the scheme is unknown to URI, returns `nil`.
+  Any scheme may be registered via `default_port/2`.
 
   ## Examples
 
@@ -40,35 +26,27 @@ defmodule URI do
       nil
 
   """
-  @spec default_port(binary) :: nil | pos_integer
   def default_port(scheme) when is_binary(scheme) do
     :elixir_config.get({:uri, scheme})
   end
 
   @doc """
-  Registers the default port `port` for the given `scheme`.
-
-  After this function is called, `port` will be returned by
-  `default_port/1` for the given scheme `scheme`. Note that this function
-  changes the default port for the given `scheme` *globally*, meaning for
-  every application.
+  Registers a scheme with a default port.
 
   It is recommended for this function to be invoked in your
-  application's start callback in case you want to register
+  application start callback in case you want to register
   new URIs.
   """
-  @spec default_port(binary, pos_integer) :: :ok
-  def default_port(scheme, port) when is_binary(scheme) and is_integer(port) and port > 0 do
+  def default_port(scheme, port) when is_binary(scheme) and port > 0 do
     :elixir_config.put({:uri, scheme}, port)
   end
 
   @doc """
   Encodes an enumerable into a query string.
 
-  Takes an enumerable that enumerates as a list of two-element
-  tuples (e.g., a map or a keyword list) and returns a string
-  in the form of `key1=value1&key2=value2...` where keys and
-  values are URL encoded as per `encode_www_form/1`.
+  Takes an enumerable (containing a sequence of two-item tuples)
+  and returns a string of the form "key1=value1&key2=value2..." where
+  keys and values are URL encoded as per `encode/2`.
 
   Keys and values can be any term that implements the `String.Chars`
   protocol, except lists which are explicitly forbidden.
@@ -79,39 +57,15 @@ defmodule URI do
       iex> URI.encode_query(hd)
       "bar=2&foo=1"
 
-      iex> query = %{"key" => "value with spaces"}
-      iex> URI.encode_query(query)
-      "key=value+with+spaces"
-
-      iex> URI.encode_query %{key: [:a, :list]}
-      ** (ArgumentError) encode_query/1 values cannot be lists, got: [:a, :list]
-
   """
-  @spec encode_query(term) :: binary
-  def encode_query(enumerable) do
-    Enum.map_join(enumerable, "&", &encode_kv_pair/1)
-  end
-
-  defp encode_kv_pair({key, _}) when is_list(key) do
-    raise ArgumentError, "encode_query/1 keys cannot be lists, got: #{inspect key}"
-  end
-
-  defp encode_kv_pair({_, value}) when is_list(value) do
-    raise ArgumentError, "encode_query/1 values cannot be lists, got: #{inspect value}"
-  end
-
-  defp encode_kv_pair({key, value}) do
-    encode_www_form(Kernel.to_string(key)) <>
-      "=" <> encode_www_form(Kernel.to_string(value))
-  end
+  def encode_query(l), do: Enum.map_join(l, "&", &pair/1)
 
   @doc """
-  Decodes a query string into a map.
+  Decodes a query string into a dictionary (by default uses a map).
 
-  Given a query string of the form of `key1=value1&key2=value2...`, this
-  function inserts each key-value pair in the query string as one entry in the
-  given `map`. Keys and values in the resulting map will be binaries. Keys and
-  values will be percent-unescaped.
+  Given a query string of the form "key1=value1&key2=value2...", produces a
+  map with one entry for each key-value pair. Each key and value will be a
+  binary. Keys and values will be percent-unescaped.
 
   Use `query_decoder/1` if you want to iterate over each value manually.
 
@@ -120,119 +74,83 @@ defmodule URI do
       iex> URI.decode_query("foo=1&bar=2")
       %{"bar" => "2", "foo" => "1"}
 
-      iex> URI.decode_query("percent=oh+yes%21", %{"starting" => "map"})
-      %{"percent" => "oh yes!", "starting" => "map"}
-
   """
-  @spec decode_query(binary, map) :: map
-  def decode_query(query, map \\ %{})
-
-  # TODO: Remove on 2.0
-  def decode_query(query, %{__struct__: _} = dict) when is_binary(query) do
-    IO.warn "URI.decode_query/2 is deprecated, please use URI.decode_query/1"
-    decode_query_into_dict(query, dict)
-  end
-
-  def decode_query(query, map) when is_binary(query) and is_map(map) do
-    decode_query_into_map(query, map)
-  end
-
-  # TODO: Remove on 2.0
-  def decode_query(query, dict) when is_binary(query) do
-    IO.warn "URI.decode_query/2 is deprecated, please use URI.decode_query/1"
-    decode_query_into_dict(query, dict)
-  end
-
-  defp decode_query_into_map(query, map) do
-    case decode_next_query_pair(query) do
-      nil ->
-        map
-      {{key, value}, rest} ->
-        decode_query_into_map(rest, Map.put(map, key, value))
-    end
-  end
-
-  defp decode_query_into_dict(query, dict) do
-    case decode_next_query_pair(query) do
-      nil ->
-        dict
-      {{key, value}, rest} ->
-        decode_query_into_dict(rest, Dict.put(dict, key, value))
+  # TODO: Deprecate giving not a map on 1.3
+  def decode_query(q, dict \\ %{}) when is_binary(q) do
+    case do_decode_query(q) do
+      nil         -> dict
+      {{k, v}, q} -> decode_query(q, Dict.put(dict, k, v))
     end
   end
 
   @doc """
-  Returns a stream of two-element tuples representing key-value pairs in the
-  given `query`.
-
-  Key and value in each tuple will be binaries and will be percent-unescaped.
+  Returns an iterator function over the query string that decodes
+  the query string in steps.
 
   ## Examples
 
-      iex> URI.query_decoder("foo=1&bar=2") |> Enum.to_list()
+      iex> URI.query_decoder("foo=1&bar=2") |> Enum.map(&(&1))
       [{"foo", "1"}, {"bar", "2"}]
 
   """
-  @spec query_decoder(binary) :: Enumerable.t
-  def query_decoder(query) when is_binary(query) do
-    Stream.unfold(query, &decode_next_query_pair/1)
+  def query_decoder(q) when is_binary(q) do
+    Stream.unfold(q, &do_decode_query/1)
   end
 
-  defp decode_next_query_pair("") do
+  defp do_decode_query("") do
     nil
   end
 
-  defp decode_next_query_pair(query) do
-    {undecoded_next_pair, rest} =
-      case :binary.split(query, "&") do
-        [next_pair, rest] -> {next_pair, rest}
-        [next_pair]       -> {next_pair, ""}
+  defp do_decode_query(q) do
+    {first, next} =
+      case :binary.split(q, "&") do
+        [first, rest] -> {first, rest}
+        [first]       -> {first, ""}
       end
 
-    next_pair =
-      case :binary.split(undecoded_next_pair, "=") do
-        [key, value] -> {decode_www_form(key), decode_www_form(value)}
-        [key]        -> {decode_www_form(key), nil}
+    current =
+      case :binary.split(first, "=") do
+        [key, value] ->
+          {decode_www_form(key), decode_www_form(value)}
+        [key] ->
+          {decode_www_form(key), nil}
       end
 
-    {next_pair, rest}
+    {current, next}
+  end
+
+  defp pair({k, _}) when is_list(k) do
+    raise ArgumentError, "encode_query/1 keys cannot be lists, got: #{inspect k}"
+  end
+
+  defp pair({_, v}) when is_list(v) do
+    raise ArgumentError, "encode_query/1 values cannot be lists, got: #{inspect v}"
+  end
+
+  defp pair({k, v}) do
+    encode_www_form(Kernel.to_string(k)) <>
+    "=" <> encode_www_form(Kernel.to_string(v))
   end
 
   @doc """
   Checks if the character is a "reserved" character in a URI.
 
-  Reserved characters are specified in
-  [RFC 3986, section 2.2](http://tools.ietf.org/html/rfc3986#section-2.2).
-
-  ## Examples
-
-      iex> URI.char_reserved?(?+)
-      true
-
+  Reserved characters are specified in [RFC3986, section 2.2](http://tools.ietf.org/html/rfc3986#section-2.2).
   """
-  @spec char_reserved?(char) :: boolean
-  def char_reserved?(char) when char in 0..0x10FFFF do
-    char in ':/?#[]@!$&\'()*+,;='
+  def char_reserved?(c) do
+    c in ':/?#[]@!$&\'()*+,;='
   end
 
   @doc """
   Checks if the character is a "unreserved" character in a URI.
 
-  Unreserved characters are specified in
-  [RFC 3986, section 2.3](http://tools.ietf.org/html/rfc3986#section-2.3).
-
-  ## Examples
-
-      iex> URI.char_unreserved?(?_)
-      true
-
+  Unreserved characters are specified in [RFC3986, section 2.3](http://tools.ietf.org/html/rfc3986#section-2.3).
   """
-  @spec char_unreserved?(char) :: boolean
-  def char_unreserved?(char) when char in 0..0x10FFFF do
-    char in ?0..?9 or
-      char in ?a..?z or
-      char in ?A..?Z or
-      char in '~_-.'
+  def char_unreserved?(c) do
+    c in ?0..?9 or
+    c in ?a..?z or
+    c in ?A..?Z or
+    c in '~_-.'
   end
 
   @doc """
@@ -240,39 +158,23 @@ defmodule URI do
 
   This is the default used by `URI.encode/2` where both
   reserved and unreserved characters are kept unescaped.
-
-  ## Examples
-
-      iex> URI.char_unescaped?(?{)
-      false
-
   """
-  @spec char_unescaped?(char) :: boolean
-  def char_unescaped?(char) when char in 0..0x10FFFF do
-    char_reserved?(char) or char_unreserved?(char)
+  def char_unescaped?(c) do
+    char_reserved?(c) or char_unreserved?(c)
   end
 
   @doc """
-  Percent-escapes the given string.
-
-  This function accepts a `predicate` function as an optional argument; if
-  passed, this function will be called with each character (byte) in `str` as
-  its argument and should return `true` if that character should not be escaped
-  and left as is.
+  Percent-escapes a URI.
+  Accepts `predicate` function as an argument to specify if char can be left as is.
 
   ## Example
 
       iex> URI.encode("ftp://s-ite.tld/?value=put it+й")
       "ftp://s-ite.tld/?value=put%20it+%D0%B9"
 
-      iex> URI.encode("a string", &(&1 != ?i))
-      "a str%69ng"
-
   """
-  @spec encode(binary, (byte -> boolean)) :: binary
-  def encode(string, predicate \\ &char_unescaped?/1)
-      when is_binary(string) and is_function(predicate, 1) do
-    for <<char <- string>>, into: "", do: percent(char, predicate)
+  def encode(str, predicate \\ &char_unescaped?/1) when is_binary(str) do
+    for <<c <- str>>, into: "", do: percent(c, predicate)
   end
 
   @doc """
@@ -284,26 +186,25 @@ defmodule URI do
       "put%3A+it%2B%D0%B9"
 
   """
-  @spec encode_www_form(binary) :: binary
-  def encode_www_form(string) when is_binary(string) do
-    for <<char <- string>>, into: "" do
-      case percent(char, &char_unreserved?/1) do
+  def encode_www_form(str) when is_binary(str) do
+    for <<c <- str>>, into: "" do
+      case percent(c, &char_unreserved?/1) do
         "%20" -> "+"
-        percent -> percent
+        pct   -> pct
       end
     end
   end
 
-  defp percent(char, predicate) do
-    if predicate.(char) do
-      <<char>>
+  defp percent(c, predicate) do
+    if predicate.(c) do
+      <<c>>
     else
-      <<"%", hex(bsr(char, 4)), hex(band(char, 15))>>
+      "%" <> hex(bsr(c, 4)) <> hex(band(c, 15))
     end
   end
 
-  defp hex(n) when n <= 9, do: n + ?0
-  defp hex(n), do: n + ?A - 10
+  defp hex(n) when n <= 9, do: <<n + ?0>>
+  defp hex(n), do: <<n + ?A - 10>>
 
   @doc """
   Percent-unescapes a URI.
@@ -314,7 +215,6 @@ defmodule URI do
       "http://elixir-lang.org"
 
   """
-  @spec decode(binary) :: binary
   def decode(uri) do
     unpercent(uri, "", false)
   catch
@@ -331,12 +231,11 @@ defmodule URI do
       "<all in/"
 
   """
-  @spec decode_www_form(binary) :: binary
-  def decode_www_form(string) do
-    unpercent(string, "", true)
+  def decode_www_form(str) do
+    unpercent(str, "", true)
   catch
     :malformed_uri ->
-      raise ArgumentError, "malformed URI #{inspect string}"
+      raise ArgumentError, "malformed URI #{inspect str}"
   end
 
   defp unpercent(<<?+, tail::binary>>, acc, spaces = true) do
@@ -362,17 +261,14 @@ defmodule URI do
   Parses a well-formed URI reference into its components.
 
   Note this function expects a well-formed URI and does not perform
-  any validation. See the "Examples" section below for examples of how
-  `URI.parse/1` can be used to parse a wide range of URIs.
+  any validation. See the examples section below of how `URI.parse/1`
+  can be used to parse a wide range of relative URIs.
 
   This function uses the parsing regular expression as defined
-  in [RFC 3986, Appendix B](http://tools.ietf.org/html/rfc3986#appendix-B).
+  in the [Appendix B of RFC3986](http://tools.ietf.org/html/rfc3986#appendix-B).
 
-  When a URI is given without a port, the value returned by
-  `URI.default_port/1` for the URI's scheme is used for the `:port` field.
-
-  If a `%URI{}` struct is given to this function, this function returns it
-  unmodified.
+  When a URI is given without a port, the values registered via
+  `URI.default_port/1` and `URI.default_port/2` are used.
 
   ## Examples
 
@@ -394,21 +290,29 @@ defmodule URI do
            port: nil, query: nil, scheme: nil, userinfo: nil}
 
   """
-  @spec parse(t | binary) :: t
-  def parse(uri)
-
   def parse(%URI{} = uri), do: uri
 
-  def parse(string) when is_binary(string) do
+  def parse(s) when is_binary(s) do
     # From http://tools.ietf.org/html/rfc3986#appendix-B
     regex = ~r/^(([a-z][a-z0-9\+\-\.]*):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/i
-    parts = nillify(Regex.run(regex, string))
+    parts = nillify(Regex.run(regex, s))
 
     destructure [_, _, scheme, _, authority, path, _, query, _, fragment], parts
     {userinfo, host, port} = split_authority(authority)
 
-    scheme = scheme && String.downcase(scheme)
-    port   = port || (scheme && default_port(scheme))
+    if authority do
+      authority = ""
+
+      if userinfo, do: authority = authority <> userinfo <> "@"
+      if host, do: authority = authority <> host
+      if port, do: authority = authority <> ":" <> Integer.to_string(port)
+    end
+
+    scheme = normalize_scheme(scheme)
+
+    if is_nil(port) and not is_nil(scheme) do
+      port = default_port(scheme)
+    end
 
     %URI{
       scheme: scheme, path: path, query: query,
@@ -418,141 +322,64 @@ defmodule URI do
   end
 
   # Split an authority into its userinfo, host and port parts.
-  defp split_authority(string) do
-    components = Regex.run(~r/(^(.*)@)?(\[[a-zA-Z0-9:.]*\]|[^:]*)(:(\d*))?/, string || "")
+  defp split_authority(s) do
+    s = s || ""
+    components = Regex.run ~r/(^(.*)@)?(\[[a-zA-Z0-9:.]*\]|[^:]*)(:(\d*))?/, s
 
     destructure [_, _, userinfo, host, _, port], nillify(components)
-    host = if host, do: host |> String.trim_leading("[") |> String.trim_trailing("]")
     port = if port, do: String.to_integer(port)
+    host = if host, do: host |> String.lstrip(?[) |> String.rstrip(?])
 
     {userinfo, host, port}
   end
 
+  defp normalize_scheme(nil),     do: nil
+  defp normalize_scheme(scheme),  do: String.downcase(scheme)
+
   # Regex.run returns empty strings sometimes. We want
   # to replace those with nil for consistency.
-  defp nillify(list) do
-    for string <- list do
-      if byte_size(string) > 0, do: string
+  defp nillify(l) do
+    for s <- l do
+      if byte_size(s) > 0, do: s
     end
   end
 
   @doc """
-  Returns the string representation of the given `URI` struct.
+  Converts the URI to string.
 
       iex> URI.to_string(URI.parse("http://google.com"))
       "http://google.com"
-
-      iex> URI.to_string(%URI{scheme: "foo", host: "bar.baz"})
-      "foo://bar.baz"
-
   """
-  @spec to_string(t) :: binary
   defdelegate to_string(uri), to: String.Chars.URI
-
-  @doc ~S"""
-  Merges two URIs.
-
-  This function merges two URIs as per
-  [RFC 3986, section 5.2](http://tools.ietf.org/html/rfc3986#section-5.2).
-
-  ## Examples
-
-      iex> URI.merge(URI.parse("http://google.com"), "/query") |> to_string
-      "http://google.com/query"
-
-      iex> URI.merge("http://example.com", "http://google.com") |> to_string
-      "http://google.com"
-
-  """
-  @spec merge(t | binary, t | binary) :: t
-  def merge(uri, rel)
-
-  def merge(%URI{authority: nil}, _rel) do
-    raise ArgumentError, "you must merge onto an absolute URI"
-  end
-  def merge(_base, %URI{scheme: rel_scheme} = rel) when rel_scheme != nil do
-    rel
-  end
-  def merge(%URI{} = base, %URI{path: rel_path} = rel) when rel_path in ["", nil] do
-    %{base | query: rel.query || base.query, fragment: rel.fragment}
-  end
-  def merge(%URI{} = base, %URI{} = rel) do
-    new_path = merge_paths(base.path, rel.path)
-    %{base | path: new_path, query: rel.query, fragment: rel.fragment}
-  end
-  def merge(base, rel) do
-    merge(parse(base), parse(rel))
-  end
-
-  defp merge_paths(nil, rel_path),
-    do: merge_paths("/", rel_path)
-  defp merge_paths(_, "/" <> _ = rel_path),
-    do: rel_path
-  defp merge_paths(base_path, rel_path) do
-    [_ | base_segments] = path_to_segments(base_path)
-    path_to_segments(rel_path)
-    |> Kernel.++(base_segments)
-    |> remove_dot_segments([])
-    |> Enum.join("/")
-  end
-
-  defp remove_dot_segments([], [head, ".." | acc]),
-    do: remove_dot_segments([], [head | acc])
-  defp remove_dot_segments([], acc),
-    do: acc
-  defp remove_dot_segments(["." | tail], acc),
-    do: remove_dot_segments(tail, acc)
-  defp remove_dot_segments([head | tail], ["..", ".." | _] = acc),
-    do: remove_dot_segments(tail, [head | acc])
-  defp remove_dot_segments(segments, [_, ".." | acc]),
-    do: remove_dot_segments(segments, acc)
-  defp remove_dot_segments([head | tail], acc),
-    do: remove_dot_segments(tail, [head | acc])
-
-  def path_to_segments(path) do
-    [head | tail] = String.split(path, "/")
-    reverse_and_discard_empty(tail, [head])
-  end
-
-  defp reverse_and_discard_empty([], acc),
-    do: acc
-  defp reverse_and_discard_empty([head], acc),
-    do: [head | acc]
-  defp reverse_and_discard_empty(["" | tail], acc),
-    do: reverse_and_discard_empty(tail, acc)
-  defp reverse_and_discard_empty([head | tail], acc),
-    do: reverse_and_discard_empty(tail, [head | acc])
 end
 
 defimpl String.Chars, for: URI do
-  def to_string(%{scheme: scheme, port: port, path: path,
-                  query: query, fragment: fragment} = uri) do
-    uri =
-      case scheme && URI.default_port(scheme) do
-        ^port -> %{uri | port: nil}
-        _     -> uri
-      end
+  def to_string(uri) do
+    scheme = uri.scheme
+
+    if scheme && (port = URI.default_port(scheme)) do
+      if uri.port == port, do: uri = %{uri | port: nil}
+    end
 
     # Based on http://tools.ietf.org/html/rfc3986#section-5.3
     authority = extract_authority(uri)
 
-    if(scheme, do: scheme <> ":", else: "") <>
-      if(authority, do: "//" <> authority, else: "") <>
-      if(path, do: path, else: "") <>
-      if(query, do: "?" <> query, else: "") <>
-      if(fragment, do: "#" <> fragment, else: "")
+    result = ""
+    if uri.scheme,   do: result = result <> uri.scheme <> ":"
+    if authority,    do: result = result <> "//" <> authority
+    if uri.path,     do: result = result <> uri.path
+    if uri.query,    do: result = result <> "?" <> uri.query
+    if uri.fragment, do: result = result <> "#" <> uri.fragment
+    result
   end
 
   defp extract_authority(%{host: nil, authority: authority}) do
     authority
   end
   defp extract_authority(%{host: host, userinfo: userinfo, port: port}) do
-    # According to the grammar at
-    # https://tools.ietf.org/html/rfc3986#appendix-A, a "host" can have a colon
-    # in it only if it's an IPv6 or "IPvFuture" address), so if there's a colon
-    # in the host we can safely surround it with [].
-    if(userinfo, do: userinfo <> "@", else: "") <>
-      if(String.contains?(host, ":"), do: "[" <> host <> "]", else: host) <>
-      if(port, do: ":" <> Integer.to_string(port), else: "")
+    authority = host
+    if userinfo, do: authority = userinfo <> "@" <> authority
+    if port, do: authority = authority <> ":" <> Integer.to_string(port)
+    authority
   end
 end

lib/elixir/lib/version.ex

@@ -64,24 +64,6 @@ defmodule Version do
   `~> 2.0`       | `>= 2.0.0 and < 3.0.0`
   `~> 2.1`       | `>= 2.1.0 and < 3.0.0`
 
-  When `allow_pre: false` is set the requirement will not match a
-  pre-release version unless the operand is a pre-release version.
-  The default is to allow always allow pre-releases but note that in
-  Hex `:allow_pre` is set to `false.` See the table below for examples.
-
-  Requirement    | Version     | `:allow_pre` | Matches
-  :------------- | :---------- | :----------- | :------
-  `~> 2.0`       | `2.1.0`     | -            | `true`
-  `~> 2.0`       | `3.0.0`     | -            | `false`
-  `~> 2.0.0`     | `2.0.1`     | -            | `true`
-  `~> 2.0.0`     | `2.1.0`     | -            | `false`
-  `~> 2.1.2`     | `2.1.3-dev` | `true`       | `true`
-  `~> 2.1.2`     | `2.1.3-dev` | `false`      | `false`
-  `~> 2.1-dev`   | `2.2.0-dev` | `false`      | `true`
-  `~> 2.1.2-dev` | `2.1.3-dev` | `false`      | `true`
-  `>= 2.1.0`     | `2.2.0-dev` | `false`      | `false`
-  `>= 2.1.0-dev` | `2.2.3-dev` | `true`       | `true`
-
   """
 
   import Kernel, except: [match?: 2]
@@ -106,7 +88,7 @@ defmodule Version do
                          build: build}
 
   defmodule Requirement do
-    defstruct [:source, :matchspec, :compiled]
+    defstruct [:source, :matchspec]
     @type t :: %__MODULE__{}
   end
 
@@ -127,12 +109,6 @@ defmodule Version do
   If given an already parsed version and requirement this function won't
   raise.
 
-  ## Options
-
-    * `:allow_pre` - when `false` pre-release versions will not match
-      unless the operand is a pre-release version, see the table above
-      for examples  (default: `true`);
-
   ## Examples
 
       iex> Version.match?("2.0.0", ">1.0.0")
@@ -148,29 +124,21 @@ defmodule Version do
       ** (Version.InvalidRequirementError) == ==1.0.0
 
   """
-  @spec match?(version, requirement, Keyword.t) :: boolean
-  def match?(version, requirement, opts \\ [])
-
-  def match?(version, requirement, opts) when is_binary(requirement) do
+  @spec match?(version, requirement) :: boolean
+  def match?(version, requirement) when is_binary(requirement) do
     case parse_requirement(requirement) do
       {:ok, requirement} ->
-        match?(version, requirement, opts)
+        match?(version, requirement)
       :error ->
         raise InvalidRequirementError, message: requirement
     end
   end
 
-  def match?(version, %Requirement{matchspec: spec, compiled: false}, opts) do
-    allow_pre = Keyword.get(opts, :allow_pre, true)
-    {:ok, result} = :ets.test_ms(to_matchable(version, allow_pre), spec)
+  def match?(version, %Requirement{matchspec: spec}) do
+    {:ok, result} = :ets.test_ms(to_matchable(version), spec)
     result != false
   end
 
-  def match?(version, %Requirement{matchspec: spec, compiled: true}, opts) do
-    allow_pre = Keyword.get(opts, :allow_pre, true)
-    :ets.match_spec_run([to_matchable(version, allow_pre)], spec) != []
-  end
-
   @doc """
   Compares two versions. Returns `:gt` if first version is greater than
   the second and `:lt` for vice versa. If the two versions are equal `:eq`
@@ -193,10 +161,10 @@ defmodule Version do
   """
   @spec compare(version, version) :: :gt | :eq | :lt
   def compare(version1, version2) do
-    do_compare(to_matchable(version1, true), to_matchable(version2, true))
+    do_compare(to_matchable(version1), to_matchable(version2))
   end
 
-  defp do_compare({major1, minor1, patch1, pre1, _}, {major2, minor2, patch2, pre2, _}) do
+  defp do_compare({major1, minor1, patch1, pre1}, {major2, minor2, patch2, pre2}) do
     cond do
       {major1, minor1, patch1} > {major2, minor2, patch2} -> :gt
       {major1, minor1, patch1} < {major2, minor2, patch2} -> :lt
@@ -233,28 +201,6 @@ defmodule Version do
     end
   end
 
-  @doc """
-  Parses a version string into a `Version`.
-
-  If `string` is an invalid version, an `InvalidVersionError` is raised.
-
-  ## Examples
-
-      iex> Version.parse!("2.0.1-alpha1")
-      #Version<2.0.1-alpha1>
-
-      iex> Version.parse!("2.0-alpha1")
-      ** (Version.InvalidVersionError) 2.0-alpha1
-
-  """
-  @spec parse!(String.t) :: t | no_return
-  def parse!(string) when is_binary(string) do
-    case parse(string) do
-      {:ok, version} -> version
-      :error -> raise InvalidVersionError, message: string
-    end
-  end
-
   @doc """
   Parses a version requirement string into a `Version.Requirement`.
 
@@ -272,36 +218,20 @@ defmodule Version do
   def parse_requirement(string) when is_binary(string) do
     case Version.Parser.parse_requirement(string) do
       {:ok, spec} ->
-        {:ok, %Requirement{source: string, matchspec: spec, compiled: false}}
+        {:ok, %Requirement{source: string, matchspec: spec}}
       :error ->
         :error
     end
   end
 
-  @doc """
-  Compiles a requirement to its internal representation with
-  `:ets.match_spec_compile/1` for faster matching.
-
-  The internal representation is opaque and can not be converted to external
-  term format and then back again without losing its properties (meaning it
-  can not be sent to a process on another node and still remain a valid
-  compiled match_spec, nor can it be stored on disk).
-  """
-  @spec compile_requirement(Requirement.t) :: Requirement.t
-  def compile_requirement(%Requirement{matchspec: spec} = req) do
-    %{req | matchspec: :ets.match_spec_compile(spec), compiled: true}
+  defp to_matchable(%Version{major: major, minor: minor, patch: patch, pre: pre}) do
+    {major, minor, patch, pre}
   end
 
-  defp to_matchable(%Version{major: major, minor: minor, patch: patch, pre: pre}, allow_pre?) do
-    {major, minor, patch, pre, allow_pre?}
-  end
-
-  defp to_matchable(string, allow_pre?) do
+  defp to_matchable(string) do
     case Version.Parser.parse_version(string) do
-      {:ok, {major, minor, patch, pre}} ->
-        {major, minor, patch, pre, allow_pre?}
-      :error ->
-        raise InvalidVersionError, message: string
+      {:ok, version} -> version
+      :error -> raise InvalidVersionError, message: string
     end
   end
 
@@ -349,16 +279,16 @@ defmodule Version do
     @moduledoc false
     import Parser.DSL
 
-    deflexer ">=",    do: :>=
-    deflexer "<=",    do: :<=
-    deflexer "~>",    do: :~>
-    deflexer ">",     do: :>
-    deflexer "<",     do: :<
-    deflexer "==",    do: :==
-    deflexer "!=",    do: :!=
-    deflexer "!",     do: :!=
-    deflexer " or ",  do: :||
-    deflexer " and ", do: :&&
+    deflexer ">=",    do: :'>='
+    deflexer "<=",    do: :'<='
+    deflexer "~>",    do: :'~>'
+    deflexer ">",     do: :'>'
+    deflexer "<",     do: :'<'
+    deflexer "==",    do: :'=='
+    deflexer "!=",    do: :'!='
+    deflexer "!",     do: :'!='
+    deflexer " or ",  do: :'||'
+    deflexer " and ", do: :'&&'
     deflexer " ",     do: :' '
 
     deflexer x, [] do
@@ -370,8 +300,8 @@ defmodule Version do
         is_binary h ->
           [h <> x | acc]
 
-        h in [:||, :&&] ->
-          [x, :==, h | acc]
+        h in [:'||', :'&&'] ->
+          [x, :'==', h | acc]
 
         true ->
           [x, h | acc]
@@ -387,10 +317,10 @@ defmodule Version do
       (?:\.(\d+))?          # minor
       (?:\.(\d+))?          # patch
       (?:\-([\d\w\.\-]+))?  # pre
-      (?:\+([\d\w\.\-]+))?  # build
+      (?:\+([\d\w\-]+))?    # build
       $/x
 
-    @spec parse_requirement(String.t) :: {:ok, term} | :error
+    @spec parse_requirement(String.t) :: {:ok, Version.Requirement.t} | :error
     def parse_requirement(source) do
       lexed = lexer(source, [])
       to_matchspec(lexed)
@@ -428,14 +358,14 @@ defmodule Version do
     defp parse_pre(nil), do: {:ok, []}
     defp parse_pre(pre), do: parse_pre(String.split(pre, "."), [])
 
-    defp parse_pre([piece | t], acc) do
+    defp parse_pre([piece|t], acc) do
       cond do
         piece =~ ~r/^(0|[1-9][0-9]*)$/ ->
-          parse_pre(t, [String.to_integer(piece) | acc])
+          parse_pre(t, [String.to_integer(piece)|acc])
         piece =~ ~r/^[0-9]*$/ ->
           :error
         true ->
-          parse_pre(t, [piece | acc])
+          parse_pre(t, [piece|acc])
       end
     end
 
@@ -489,7 +419,7 @@ defmodule Version do
       if valid_requirement?(lexed) do
         first = to_condition(lexed)
         rest  = Enum.drop(lexed, 2)
-        {:ok, [{{:'$1', :'$2', :'$3', :'$4', :'$5'}, [to_condition(first, rest)], [:'$_']}]}
+        {:ok, [{{:'$1', :'$2', :'$3', :'$4'}, [to_condition(first, rest)], [:'$_']}]}
       else
         :error
       end
@@ -497,64 +427,77 @@ defmodule Version do
       :invalid_matchspec -> :error
     end
 
-    defp to_condition([:==, version | _]) do
-      matchable = parse_condition(version)
-      main_condition(:==, matchable)
+    defp to_condition([:'==', version | _]) do
+      version = parse_condition(version)
+      {:'==', :'$_', {:const, version}}
     end
 
-    defp to_condition([:!=, version | _]) do
-      matchable = parse_condition(version)
-      main_condition(:'/=', matchable)
+    defp to_condition([:'!=', version | _]) do
+      version = parse_condition(version)
+      {:'/=', :'$_', {:const, version}}
     end
 
-    defp to_condition([:~>, version | _]) do
+    defp to_condition([:'~>', version | _]) do
       from = parse_condition(version, true)
       to   = approximate_upper(from)
 
-      {:andalso, to_condition([:>=, matchable_to_string(from)]),
-                 to_condition([:<, matchable_to_string(to)])}
+      {:andalso, to_condition([:'>=', matchable_to_string(from)]),
+                 to_condition([:'<', matchable_to_string(to)])}
     end
 
-    defp to_condition([:>, version | _]) do
+    defp to_condition([:'>', version | _]) do
       {major, minor, patch, pre} = parse_condition(version)
 
-      {:andalso, {:orelse, main_condition(:>, {major, minor, patch}),
-                           {:andalso, main_condition(:==, {major, minor, patch}),
-                                      pre_condition(:>, pre)}},
-                  no_pre_condition(pre)}
+      {:orelse, {:'>', {{:'$1', :'$2', :'$3'}},
+                       {:const, {major, minor, patch}}},
+                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
+                                        {:const, {major, minor, patch}}},
+                {:orelse, {:andalso, {:'==', {:length, :'$4'}, 0},
+                                     {:'/=', length(pre), 0}},
+                          {:andalso, {:'/=', length(pre), 0},
+                                     {:orelse, {:'>', {:length, :'$4'}, length(pre)},
+                                     {:andalso, {:'==', {:length, :'$4'}, length(pre)},
+                                                {:'>', :'$4', {:const, pre}}}}}}}}
     end
 
-    defp to_condition([:>=, version | _]) do
+    defp to_condition([:'>=', version | _]) do
       matchable = parse_condition(version)
 
-      {:orelse, main_condition(:==, matchable),
-                to_condition([:>, version])}
+      {:orelse, {:'==', :'$_', {:const, matchable}},
+                to_condition([:'>', version])}
     end
 
-    defp to_condition([:<, version | _]) do
+    defp to_condition([:'<', version | _]) do
       {major, minor, patch, pre} = parse_condition(version)
 
-      {:orelse, main_condition(:<, {major, minor, patch}),
-                {:andalso, main_condition(:==, {major, minor, patch}),
-                           pre_condition(:<, pre)}}
+      {:orelse, {:'<', {{:'$1', :'$2', :'$3'}},
+                       {:const, {major, minor, patch}}},
+                {:andalso, {:'==', {{:'$1', :'$2', :'$3'}},
+                                   {:const, {major, minor, patch}}},
+                {:orelse, {:andalso, {:'/=', {:length, :'$4'}, 0},
+                                     {:'==', length(pre), 0}},
+                          {:andalso, {:'/=', {:length, :'$4'}, 0},
+                          {:orelse, {:'<', {:length, :'$4'}, length(pre)},
+                                    {:andalso, {:'==', {:length, :'$4'}, length(pre)},
+                                               {:'<', :'$4', {:const, pre}}}}}}}}
     end
 
-    defp to_condition([:<=, version | _]) do
+    defp to_condition([:'<=', version | _]) do
       matchable = parse_condition(version)
 
-      {:orelse, main_condition(:==, matchable),
-                to_condition([:<, version])}
+      {:orelse, {:'==', :'$_', {:const, matchable}},
+                to_condition([:'<', version])}
     end
 
     defp to_condition(current, []) do
       current
     end
 
-    defp to_condition(current, [:&&, operator, version | rest]) do
+    defp to_condition(current, [:'&&', operator, version | rest]) do
       to_condition({:andalso, current, to_condition([operator, version])}, rest)
     end
 
-    defp to_condition(current, [:||, operator, version | rest]) do
+    defp to_condition(current, [:'||', operator, version | rest]) do
       to_condition({:orelse, current, to_condition([operator, version])}, rest)
     end
 
@@ -565,45 +508,6 @@ defmodule Version do
       end
     end
 
-    defp main_condition(op, version) when tuple_size(version) == 3 do
-      {op, {{:'$1', :'$2', :'$3'}},
-           {:const, version}}
-    end
-
-    defp main_condition(op, version) when tuple_size(version) == 4 do
-      {op, {{:'$1', :'$2', :'$3', :'$4'}},
-           {:const, version}}
-    end
-
-    defp pre_condition(:>, pre) do
-      length_pre = length(pre)
-
-      {:orelse, {:andalso, {:==, {:length, :'$4'}, 0},
-                           {:const, length_pre != 0}},
-                {:andalso, {:const, length_pre != 0},
-                           {:orelse, {:>, {:length, :'$4'}, length_pre},
-                                     {:andalso, {:==, {:length, :'$4'}, length_pre},
-                                                {:>, :'$4', {:const, pre}}}}}}
-    end
-
-    defp pre_condition(:<, pre) do
-      length_pre = length(pre)
-
-      {:orelse, {:andalso, {:'/=', {:length, :'$4'}, 0},
-                           {:const, length_pre == 0}},
-                {:andalso, {:'/=', {:length, :'$4'}, 0},
-                           {:orelse, {:<, {:length, :'$4'}, length_pre},
-                                     {:andalso, {:==, {:length, :'$4'}, length_pre},
-                                                {:<, :'$4', {:const, pre}}}}}}
-    end
-
-    defp no_pre_condition([]) do
-      {:orelse, :'$5', {:==, {:length, :'$4'}, 0}}
-    end
-    defp no_pre_condition(_pre) do
-      {:const, true}
-    end
-
     defp matchable_to_string({major, minor, patch, pre}) do
       patch = if patch, do: "#{patch}", else: "0"
       pre   = if pre != [], do: "-#{Enum.join(pre, ".")}"

lib/elixir/pages/Behaviours.md

@@ -1,52 +0,0 @@
-# Behaviours
-
-Behaviours in Elixir (and Erlang) are a way to separate and abstract the generic part of a component (which becomes the *behaviour module*) from the specific part (which becomes the *callback module*).
-
-A behaviour module defines a set of functions and macros (referred to as *callbacks*) that callback modules implementing that behaviour must export. This "interface" identifies the specific part of the component. For example, the `GenServer` behaviour and functions abstract away all the message-passing (sending and receiving) and error reporting that a "server" process will likely want to implement from the specific parts such as the actions that this server process has to perform.
-
-If a callback module that implements a given behaviour doesn't export all the functions and macros defined by that behaviour, the user will be notified through warnings during the compilation process (no errors will happen).
-
-Elixir's standard library contains a few frequently used behaviours such as `GenServer`, `Supervisor`, and `Application`.
-
-## Defining a behaviour
-
-A behaviour is always backed by a module (which is how the behaviour will be identified): the module where callbacks are defined. To define a behaviour module, it's enough to define one or more callbacks in that module. To define callbacks, the `@callback` and `@macrocallback` module attributes can be used (for function callbacks and macro callbacks respectively).
-
-    defmodule MyBehaviour do
-      @callback my_fun(arg :: any) :: any
-      @macrocallback my_macro(arg :: any) :: Macro.t
-    end
-
-As seen in the example above, defining a callback is a matter of defining a specification for that callback, made of:
-
-  * the callback name (`my_fun` or `my_macro` in the example)
-  * the arguments that the callback must accept (`arg :: any` in the example)
-  * the *expected* type of the callback return value
-
-For more information on typespecs, consult the ["Typespecs"](typespecs.html) page in the Elixir documentation. As mentioned in this page, type specification are only annotations used by documentation and tools, so defining such specifications for behaviours serves mostly for such purposes.
-
-### Optional callbacks
-
-Optional callbacks are callbacks that callback modules may implement if they want to, but are not required to. Usually, behaviour modules provide a default implementation for such callbacks in case the callback module does not implement them. Optional callbacks can be defined through the `@optional_callbacks` module attribute, which has to be a list of `{function_or_macro_name, arity}` tuples. For example:
-
-    defmodule MyBehaviour do
-      @callback vital_fun() :: any
-      @callback non_vital_fun() :: any
-      @macrocallback non_vital_macro(arg :: any) :: Macro.t
-      @optional_callbacks non_vital_fun: 0, non_vital_macro: 1
-    end
-
-One example of optional callback in Elixir's standard library is `c:GenServer.format_status/2`.
-
-## Implementing behaviours
-
-To specify that a module implements a given behaviour, the `@behaviour` attribute must be used:
-
-    defmodule MyBehaviour do
-      @callback my_fun(arg :: any) :: any
-    end
-
-    defmodule MyCallbackModule do
-      @behaviour MyBehaviour
-      def my_fun(arg), do: arg
-    end

lib/elixir/pages/Naming Conventions.md

@@ -1,108 +0,0 @@
-# Naming Conventions
-
-This document covers some naming conventions in Elixir code, from casing to punctuation characters.
-
-## Casing
-
-Elixir developers must use `snake_case` when defining variables, function names, module attributes, etc:
-
-    some_map = %{this_is_a_key: "and a value"}
-    is_map(some_map)
-
-Aliases, commonly used as module names, are an exception as they must be capitalized and written in `CamelCase`, like `OptionParser`. For aliases, capital letters are kept in acronyms, like `ExUnit.CaptureIO` or `Mix.SCM`.
-
-Atoms can be written either in `:snake_case` or `:CamelCase`, although the convention is to use the snake case version throughout Elixir.
-
-Generally speaking, filenames follow the `snake_case` convention of the module they define. For example, `MyApp` should be defined inside the `my_app.ex` file. However, this is only a convention. At the end of the day, any filename can be used as they do not affect the compiled code in any way.
-
-## Underscore (_foo)
-
-Elixir relies on underscores in different situations.
-
-For example, a value that is not meant to be used must be assigned to `_` or to a variable starting with underscore:
-
-    iex> {:ok, _contents} = File.read("README.md")
-
-Function names may also start with an underscore. Such functions are never imported by default:
-
-    iex> defmodule Example do
-    ...>   def _wont_be_imported do
-    ...>     :oops
-    ...>   end
-    ...> end
-
-    iex> import Example
-    iex> _wont_be_imported()
-    ** (CompileError) iex:1: undefined function _wont_be_imported/0
-
-Due to this property, Elixir relies on functions starting with underscore to attach compile-time metadata to modules. Such functions are most often in the `__foo__` format. For example, every module in Elixir has an `__info__` function:
-
-    iex> String.__info__(:functions)
-    [at: 2, capitalize: 1, chunk: 2, ...]
-
-Elixir also includes 4 special variables that follow the double underscore format. These forms retrieve compile-time information about the current environment: `__MODULE__`, `__DIR__`, `__ENV__` and `__CALLER__`.
-
-## Trailing bang (foo!)
-
-A trailing bang (exclamation mark) signifies a function or macro where failure cases raise an exception.
-
-Many functions come in pairs, such as `File.read/1` and `File.read!/1`. `File.read/1` will return a success or failure tuple, whereas `File.read!/1` will return a plain value or else raise an exception:
-
-    iex> File.read("file.txt")
-    {:ok, "file contents"}
-    iex> File.read("no_such_file.txt")
-    {:error, :enoent}
-
-    iex> File.read!("file.txt")
-    "file contents"
-    iex> File.read!("no_such_file.txt")
-    ** (File.Error) could not read file no_such_file.txt: no such file or directory
-
-The version without `!` is preferred when you want to handle different outcomes using pattern matching:
-
-    case File.read(file) do
-      {:ok, body}      -> # do something with the `body`
-      {:error, reason} -> # handle the error caused by `reason`
-    end
-
-However, if you expect the outcome to always to be successful (e.g. if you expect the file always to exist), the bang variation can be more convenient and will raise a more helpful error message (than a failed pattern match) on failure.
-
-More examples of paired functions: `Base.decode16/2` and `Base.decode16!/2`, `File.cwd/0` and `File.cwd!/0`
-
-There are also some non-paired functions, with no non-bang variant. The bang still signifies that it will raise an exception on failure. Examples: `Mix.Config.validate!/1`, `Protocol.assert_protocol!/1`
-
-In macro code, the bang on `Kernel.alias!/1` and `Kernel.var!/2` signifies that [macro hygiene](http://elixir-lang.org/getting-started/meta/macros.html#macros-hygiene) is set aside.
-
-## Trailing question mark (foo?)
-
-Functions that return a boolean are named with a trailing question mark.
-
-Examples: `Keyword.keyword?/1`, `Mix.debug?/0`, `String.contains?/2`
-
-However, functions that return booleans and are valid in guards follow another convention, described next.
-
-## is_ prefix (is_foo)
-
-Type checks and other boolean checks that are allowed in guard clauses are named with an `is_` prefix.
-
-Examples: `Integer.is_even/1`, `Kernel.is_list/1`
-
-These functions and macros follow the Erlang convention of an `is_` prefix, instead of a trailing question mark, precisely to indicate that they are allowed in guard clauses.
-
-Note that type checks that are not valid in guard clauses do not follow this convention. Examples: `Keyword.keyword?/1`, `Regex.regex?/1`
-
-## Special names
-
-Some names have specific meaning in Elixir. We detail those cases below.
-
-### length and size
-
-When you see `size` in a function name, it means the operation runs in constant time (also written as "O(1) time") because the size is stored alongside the data structure.
-
-Examples: `Kernel.map_size/1`, `Kernel.tuple_size/1`
-
-When you see `length`, the operation runs in linear time ("O(n) time") because the entire data structure has to be traversed.
-
-Examples: `Kernel.length/1`, `String.length/1`
-
-In other words, `size` functions will take the same amount of time whether the data structure is tiny or huge. `length` functions will take more time as the data structure grows in size.

lib/elixir/pages/Typespecs.md

@@ -1,24 +1,28 @@
 # Typespecs
 
-Elixir comes with a notation for declaring types and specifications. Elixir is a dynamically typed language, and as such, type specifications are never used by the compiler to optimize or modify code. Still, using type specifications is useful because
+Elixir comes with a notation for declaring types and specifications. Elixir is
+dynamically typed, and as such, typespecs are never used by the compiler to
+optimize or modify code. Still, using typespecs is useful as documentation and
+tools such as [Dialyzer](http://www.erlang.org/doc/man/dialyzer.html) can
+analyze code with typespecs to find bugs.
 
-  * they provide documentation (for example, tools such as [ExDoc](https://github.com/elixir-lang/ex_doc) show type specifications in the documentation)
-  * they're used by tools sych as [Dialyzer](http://www.erlang.org/doc/man/dialyzer.html), that can analyze code with typespec to find type inconsistencies and possible bugs
-
-Type specifications (sometimes referred to as *typespecs*) are defined in different contexts using the following attributes:
-
-  * `@type`
-  * `@opaque`
-  * `@typep`
-  * `@spec`
-  * `@callback`
-  * `@macrocallback`
-
-See the "Defining a type" and "Defining a specification" sub-sections below for more information on defining types and typespecs.
+The attributes `@type`, `@opaque`, `@typep`, `@spec`, `@callback` and
+`@macrocallback` available in modules are handled by the equivalent macros
+defined by this module. See sub-sections "Defining a type" and "Defining a
+specification" below.
 
 ## Types and their syntax
 
-The syntax Elixir provides for type specifications is similar to [the one in Erlang](http://www.erlang.org/doc/reference_manual/typespec.html). Most of the built-in types provided in Erlang (for example, `pid()`) are expressed in the same way: `pid()` (or simply `pid`). Parametrized types (such as `list(integer)`) are supported as well and so are remote types (such as `Enum.t`). Integers and atom literals are allowed as types (e.g., `1`, `:atom`, or `false`). All other types are built out of unions of predefined types. Some shorthands are allowed, such as `[...]`, `<<>>`, and `{...}`.
+The type syntax provided by Elixir is fairly similar to [the one in
+Erlang](http://www.erlang.org/doc/reference_manual/typespec.html).
+
+Most of the built-in types provided in Erlang (for example, `pid()`) are
+expressed the same way: `pid()` or simply `pid`. Parameterized types are also
+supported (`list(integer)`) and so are remote types (`Enum.t`).
+
+Integers and atom literals are allowed as types (ex. `1`, `:atom` or
+`false`). All other types are built of unions of predefined types. Certain
+shorthands are allowed, such as `[...]`, `<<>>` and `{...}`.
 
 ### Basic types
 
@@ -34,15 +38,15 @@ The syntax Elixir provides for type specifications is similar to [the one in Erl
           | pos_integer()           # 1, 2, 3, ...
           | neg_integer()           # ..., -3, -2, -1
           | float()
-          | map()                   # any map
-          | struct()                # any struct
+          | map()
+          | struct()
           | list(type)
           | nonempty_list(type)
           | improper_list(type1, type2)
           | maybe_improper_list(type1, type2)
           | Literals                # Described in section "Literals"
-          | Builtin                 # Described in section "Built-in types"
-          | Remotes                 # Described in section "Remote types"
+          | Builtin                 # Described in section "Builtin-types"
+          | Remotes                 # Described in section "Remotes"
 
 ### Literals
 
@@ -53,40 +57,35 @@ The following literals are also supported in typespecs:
           | 1..10                         ## Integers from 1 to 10
           | 1.0                           ## Floats
 
-                                          ## Bitstrings
-          | <<>>                          # empty bitstring
-          | <<_::size>>                   # size is 0 or a positive integer
-          | <<_::_ * unit>>               # unit is an integer from 1 to 256
-          | <<_::size, _::_*unit>>
+          | <<>>                          ## Bitstrings
+          | <<_::size>>                 # size is 0 or a positive integer
+          | <<_::_ * unit>>             # unit is an integer from 1 to 256
+          | <<_::size * unit>>
 
-                                          ## Lists
-          | [type]                        # list with any number of type elements
+          | [type]                        ## Lists
           | []                            # empty list
           | [...]                         # shorthand for nonempty_list(any())
           | [type, ...]                   # shorthand for nonempty_list(type)
           | [key: type]                   # keyword lists
 
-                                          ## Functions
+          | (... -> type)                 ## Functions
           | (... -> type)                 # any arity, returns type
           | (() -> type)                  # 0-arity, returns type
           | (type1, type2 -> type)        # 2-arity, returns type
 
-                                          ## Maps
-          | %{}                           # empty map
-          | %{...}                        # any map
-          | %{key: type}                  # map with required key :key with value of type
-          | %{required(type1) => type2}   # map with required keys of type1 with values of type2
-          | %{optional(type1) => type2}   # map with optional keys of type1 with values of type2
-          | %SomeStruct{}                 # struct with all fields of any type
-          | %SomeStruct{key: type}        # struct with :key field of type
+          | %{}                           ## Maps
+          | %{key: type}                  # map with key :key with value of type
+          | %{type1 => type2}             # map with keys of type1 with values of type2
+          | %SomeStruct{}
+          | %SomeStruct{key: type}
 
-                                          ## Tuples
-          | {}                            # empty tuple
+          | {}                            ## Tuples
           | {:ok, type}                   # two element tuple with an atom and any type
 
 ### Built-in types
 
-The following types are also provided by Elixir as shortcuts on top of the basic and literal types described above.
+These types are also provided by Elixir as shortcuts on top of the
+basic and literal types.
 
 Built-in type           | Defined as
 :---------------------- | :---------
@@ -95,50 +94,42 @@ Built-in type           | Defined as
 `bitstring()`           | `<<_::_ * 1>>`
 `boolean()`             | `false` \| `true`
 `byte()`                | `0..255`
-`char()`                | `0..0x10FFFF`
+`char()`                | `0..0x10ffff`
 `number()`              | `integer()` \| `float()`
-`charlist()`            | `[char()]`
+`char_list()`           | `[char()]`
 `list()`                | `[any()]`
 `maybe_improper_list()` | `maybe_improper_list(any(), any())`
 `nonempty_list()`       | `nonempty_list(any())`
-`iolist()`              | `maybe_improper_list(byte() \| binary() \| iolist(), binary() \| [])`
 `iodata()`              | `iolist()` \| `binary()`
+`iolist()`              | `maybe_improper_list(byte()` \| `binary()` \| `iolist(), binary()` \| `[])`
 `module()`              | `atom()` \| `tuple()`
 `arity()`               | `0..255`
 `mfa()`                 | `{atom(), atom(), arity()}`
-`identifier()`          | `pid()` \| `port()` \| `reference()`
 `node()`                | `atom()`
 `timeout()`             | `:infinity` \| `non_neg_integer()`
 `no_return()`           | `none()`
 `fun()`                 | `(... -> any)`
 `struct()`              | `%{__struct__: atom()}`
 `as_boolean(t)`         | `t`
-`keyword()`             | `[{atom(), any()}]`
-`keyword(t)`            | `[{atom(), t}]`
 
 ### Remote types
 
-Any module is also able to define its own types and the modules in Elixir are no exception. For example, the `Range` module defines a `t` type that represents a range: this type can be referred to as `Range.t`. In a similar fashion, a string is `String.t`, any enumerable can be `Enum.t`, and so on.
-
-### Maps
-
-The key types in maps are allowed to overlap, and if they do, the leftmost key takes precedence. A map value does not belong to this type if it contains a key that is not in the maps allowed keys.
-
-Because it is common to end a map type with `optional(any) => any` to denote that keys that do not belong to any other key in the map type are allowed, and may map to any value, the shorthand notation `...` is allowed as the last element of a map type.
-
-Notice that the syntactic representation of `map()` is `%{...}` (or `%{optional(any) => any}`), not `%{}`. The notation `%{}` specifies the singleton type for the empty map.
+Any module is also able to define its own type and the modules in
+Elixir are no exception. For example, a string is `String.t`, a
+range is `Range.t`, any enumerable can be `Enum.t` and so on.
 
 ## Defining a type
 
-The `@type`, `@typep`, and `@opaque` module attributes can be used to define new types:
-
     @type type_name :: type
     @typep type_name :: type
     @opaque type_name :: type
 
-A type defined with `@typep` is private. An opaque type, defined with `@opaque` is a type where the internal structure of the type will not be visible, but the type is still public.
+A type defined with `@typep` is private. An opaque type, defined with
+`@opaque` is a type where the internal structure of the type will not be
+visible, but the type is still public.
 
-Types can be parameterized by defining variables as parameters; these variables can then be used to define the type.
+Types can be parameterized by defining variables as parameters, these variables
+can then be used to define the type.
 
     @type dict(key, value) :: [{key, value}]
 
@@ -148,9 +139,11 @@ Types can be parameterized by defining variables as parameters; these variables
     @callback function_name(type1, type2) :: return_type
     @macrocallback macro_name(type1, type2) :: Macro.t
 
-Callbacks are used to define the callbacks functions of behaviours (see the ["Behaviours"](behaviours.html) page in the documentation for more information on behaviours).
+Callbacks are used to define the callbacks functions of behaviours (see
+`Behaviour`).
 
-Guards can be used to restrict type variables given as arguments to the function.
+Guards can be used to restrict type variables given as arguments to the
+function.
 
     @spec function(arg) :: [arg] when arg: atom
 
@@ -158,18 +151,18 @@ Type variables with no restriction can also be defined.
 
     @spec function(arg) :: [arg] when arg: var
 
-You can also name your arguments in a typespec using `arg_name :: arg_type` syntax. This is particularly useful in documentation as a way to differentiate multiple arguments of the same type (or multiple elements of the same type in a type definition):
-
-    @spec days_since_epoch(year :: integer, month :: integer, day :: integer) :: integer
-    @type color :: {red :: integer, green :: integer, blue :: integer}
-
 Specifications can be overloaded just like ordinary functions.
 
     @spec function(integer) :: atom
-    @spec function(atom) :: integer
+    @spec function(atom)    :: integer
 
 ## Notes
 
-Elixir discourages the use of type `string` as it might be confused with binaries which are referred to as "strings" in Elixir (as opposed to character lists). In order to use the type that is called `string` in Erlang, one has to use the `charlist` type which is a synonym for `string`. If you use `string`, you'll get a warning from the compiler.
+Elixir discourages the use of type `string` as it might be confused with
+binaries which are referred to as "strings" in Elixir (as opposed to character
+lists). In order to use the type that is called `string` in Erlang, one has to
+use the `char_list` type which is a synonym for `string`. If you use `string`,
+you'll get a warning from the compiler.
 
-If you want to refer to the "string" type (the one operated on by functions in the `String` module), use `String.t` type instead.
+If you want to refer to the "string" type (the one operated on by functions in
+the `String` module), use `String.t` type instead.

lib/elixir/pages/Writing Documentation.md

@@ -34,34 +34,29 @@ Documentation in Elixir is usually attached to module attributes. Let's see an e
       end
     end
 
-The `@moduledoc` attribute is used to add documentation to the module. `@doc` is used before a function to provide documentation for it. Besides the attributes above, `@typedoc` can also be used to attach documentation to types defined as part of typespecs.
+The `@moduledoc` attribute is used to attach documentation to the module. `@doc` is used before a function to attach documentation to it. Besides the attributes above, `@typedoc` can also be used to attach documentation to types defined as part of typespecs.
 
 ## Function Arguments
 
 When documenting a function, argument names are inferred by the compiler. For example:
 
-    def size(%{size: size}) do
+    def size(%HashDict{size: size}) do
       size
     end
 
-The compiler will infer this argument as `map`. Sometimes the inference will be suboptimal, specially if the function contains multiple clauses with the argument matching on different values each time. You can specify the proper names for documentation by declaring before a bodyless clause:
+The compiler will infer this argument as `hash_dict`. Sometimes the inference will be suboptimal, specially if the function contains multiple clauses with the argument matching on different values each time. You can specify the proper names for documentation by using a bodyless clause:
 
-    def size(map)
-    def size(%{size: size}) do
-      size
-    end
+    def size(dict)
 
 ## Recommendations
 
 There are a couple tips we recommend developers to follow when writing documentation:
 
-  * Keep the first paragraph of the documentation concise and simple, typically one-line. Tools like [ExDoc](https://github.com/elixir-lang/ex_doc/) use the first line to generate a summary.
+  * Keep the first paragraph of the documentation concise and simple. Tools like ExDoc uses the first line to generate a summary.
 
-  * Markdown uses backticks (`` ` ``) to quote code. Elixir builds on top of that to automatically generate links when module or function names are referenced. For this reason, always use full module names. If you have a module called `MyApp.Hello`, always reference it as `` `MyApp.Hello` `` and never as `` `Hello` ``. Function names must be referenced by name and arity if they are local, as in `` `world/1` ``, or by module, name and arity if pointing to an external module: `` `MyApp.Hello.world/1` ``. Referencing a `@callback` can be done by prepending `c:`, as in `` `c:world/1` ``; and a `@type` by using `t:`, as in `t:values/0`.
+  * Markdown uses backticks (`` ` ``) to quote code. Elixir builds on top of that to automatically generate links when modules or function names are referenced. For this reason, always use full module names. If you have a module called `MyApp.Hello`, always reference it as `` `MyApp.Hello` `` and never as `` `Hello` ``. Function names must be referenced by name and arity if they are local, as in `` `world/1` ``, or by module, name and arity if pointing to an external module: `` `MyApp.Hello.world/1` ``. Referencing a `@callback` can be done by prepending `c:`, as in `` `c:world/1` ``.
 
-  * When the documentation has multiple sections, always start the section heading by using `##`. The first heading is reserved for modules and function names.
-
-  * When documenting a function with multiple clauses, the documentation must be placed before the first clause. Documentation is always per function and arity and not per clause.
+  * If using headings, always start from the second heading by using `##`. The first heading is reserved to the module or function name itself.
 
 ## Doctests
 
@@ -69,50 +64,39 @@ We recommend developers to include examples in their documentation, often under
 
 Notice doctests have limitations. When you cannot doctest a function, because it relies on state or side-effects, we recommend developers to include examples directly without the `iex>` prompt.
 
-## Documentation != Comments
+## Privacy
 
-Elixir treats documentation and code comments as different concepts. Documentation are for users of your Application Programming Interface (API), be it your co-worker or your future self. Modules and functions must always be documented if they are part of your API.
-
-Code comments are for developers reading the code. They are useful to mark improvements, leave notes for developers reading the code (for example, you decided not to call a function due to a bug in a library) and so forth.
-
-In other words: documentation is required, code comments are optional.
-
-## Hiding Internal Modules and Functions
-
-Besides the modules and functions libraries provided as part of their public interface, libraries may also implement important functionality that are not part of their API. While these modules and functions can be accessed, they are meant to be internal to the library and thus should not have documentation for end users.
-
-Luckily, Elixir allows developers to hide modules and functions from the documentation. For example, one common practice for documenting internal behaviour is to set the `@moduledoc` attribute to `false` while documenting each function:
+Elixir allows developers to hide both modules and functions from the documentation by setting the doc attribute to false:
 
     defmodule MyApp.Hidden do
       @moduledoc false
 
-      @doc """
-      This function won't be listed in docs.
-      """
-      def function_that_wont_be_listed_in_docs do
+      def this_will_be_ignored_by_tools do
         # ...
       end
     end
 
-Similarly, developers can add `@doc false` to functions they do not want to be publicly exposed:
+Notice that, although developers can add `@doc false` to functions, it does not make the function private:
 
     defmodule MyApp.Sample do
       @doc false
       def add(a, b), do: a + b
     end
 
-However keep in mind adding `@doc false` does not make the function private. The function above can still be invoked as `MyApp.Sample.add(1, 2)`. Not only that, if `MyApp.Sample` is imported, the `add/2` function will also be imported into the caller. For those reasons, be cautious when adding `@doc false` to functions, instead prefer one of:
+The function above can still be invoked as `MyApp.Sample.add(1, 2)`. Not only that, if the `MyApp.Sample` is imported, the `add/2` function will also be imported into the caller. For those reasons, be wary when adding `@doc false` to functions, instead prefer one of:
 
-  * Move the undocumented function to a module with `@moduledoc false`, like `MyApp.Hidden`, ensuring the function won't be accidentally exposed or imported. Remember you can use `@moduledoc false` to hide a whole module and still document each function with `@doc`. Tools will still ignore the module.
+  * Move the private function to a module with `@moduledoc false`, like `MyApp.Hidden`, ensuring the function won't be accidentally exposed or imported. In fact, you can use `@moduledoc false` to hide a whole module and still document each function with `@doc`. Tools will still ignore the module.
 
-  * Start the function name with one or two underscores, for example, `__add__/2`, and add `@doc false`. The compiler does not import functions with leading underscores and they hint to anyone reading the code of their intended private usage.
+  * Start the function name with underscores, for example, `__add__/2`, and add `@doc false`. The compiler does not import functions with underscore and the underscore will tell users to be wary of using it.
 
-## Documenting Private Functions
+## Documentation != Comments
 
-Elixir warns if a private function has a `@doc` attribute and discards its content, because `@doc` is intended to be used only for your public interface.
+Elixir makes the difference between documentation and code comments. Documentation are for users of your API, be it your co-worker or your future self. Modules and functions must always be documented if they are part of your application public interface (API).
 
-Private functions may still need internal documentation for maintainers, though. That can be accomplished with code commments.
+Code comments are for developers reading the code. They are useful to mark improvements, leave notes for developers reading the code (for example, you decided to not call a function due to a bug in a library) and so forth.
+
+In other words, documentation is required, code comments are optional.
 
 ## Code.get_docs/2
 
-Elixir stores documentation inside pre-defined chunks in the bytecode. It can be accessed from Elixir by using the `Code.get_docs/2` function. This also means documentation is only accessed when required and not when modules are loaded by the Virtual Machine. The only downside is that modules defined in-memory, like the ones defined in IEx, cannot have their documentation accessed as they do not have their bytecode written to disk.
+Elixir stores documentation inside pre-defined chunks in the bytecode. It can be accessed from Elixir by using the `Code.get_docs/2` function. This also means documentation is only accessed when required and not when modules are loaded by the Virtual Machine. The only downside is that modules defined in-memory, like the ones defined via IEx, cannot have their documentation accessed.

lib/elixir/src/elixir.erl

@@ -10,14 +10,10 @@
 -define(system, 'Elixir.System').
 
 %% Top level types
-%% TODO: Deprecate char_list type by v1.5
--export_type([charlist/0, char_list/0, struct/0, as_boolean/1, keyword/0, keyword/1]).
--type charlist() :: string().
+-export_type([char_list/0, struct/0, as_boolean/1]).
 -type char_list() :: string().
 -type struct() :: #{'__struct__' => atom()}.
 -type as_boolean(T) :: T.
--type keyword() :: [{atom(), any()}].
--type keyword(T) :: [{atom(), T}].
 
 %% OTP Application API
 
@@ -71,12 +67,13 @@ start(_Type, _Args) ->
       ok
   end,
 
-  URIConfig = [{{uri, <<"ftp">>}, 21},
-               {{uri, <<"sftp">>}, 22},
-               {{uri, <<"tftp">>}, 69},
-               {{uri, <<"http">>}, 80},
-               {{uri, <<"https">>}, 443},
-               {{uri, <<"ldap">>}, 389}],
+  URIs = [{<<"ftp">>, 21},
+          {<<"sftp">>, 22},
+          {<<"tftp">>, 69},
+          {<<"http">>, 80},
+          {<<"https">>, 443},
+          {<<"ldap">>, 389}],
+  URIConfig = [{{uri, Scheme}, Port} || {Scheme, Port} <- URIs],
   CompilerOpts = #{docs => true, ignore_module_conflict => false,
                    debug_info => true, warnings_as_errors => false},
   {ok, [[Home] | _]} = init:get_argument(home),
@@ -187,7 +184,7 @@ eval_quoted(Tree, Binding, #{line := Line} = E) ->
   eval_forms(elixir_quote:linify(Line, Tree), Binding, E).
 
 %% Handle forms evaluation. The main difference to
-%% eval_quoted is that it does not linefy the given
+%% to eval_quoted is that it does not linefy the given
 %% args.
 
 eval_forms(Tree, Binding, Opts) when is_list(Opts) ->
@@ -240,7 +237,7 @@ get_stacktrace(CurrentStack, CurrentStack) ->
 get_stacktrace([StackItem | Stacktrace], CurrentStack) ->
   [StackItem | get_stacktrace(Stacktrace, CurrentStack)].
 
-%% Converts a quoted expression to Erlang abstract format
+%% Converts a quoted expression to erlang abstract format
 
 quoted_to_erl(Quoted, Env) ->
   quoted_to_erl(Quoted, Env, elixir_env:env_to_scope(Env)).
@@ -250,10 +247,10 @@ quoted_to_erl(Quoted, Env, Scope) ->
   {Erl, NewScope}    = elixir_translator:translate(Expanded, Scope),
   {Erl, NewEnv, NewScope}.
 
-%% Converts a given string (charlist) into quote expression
+%% Converts a given string (char list) into quote expression
 
 string_to_quoted(String, StartLine, File, Opts) when is_integer(StartLine), is_binary(File) ->
-  case elixir_tokenizer:tokenize(String, StartLine, [{file, File} | Opts]) of
+  case elixir_tokenizer:tokenize(String, StartLine, [{file, File}|Opts]) of
     {ok, _Line, _Column, Tokens} ->
       put(elixir_parser_file, File),
       try elixir_parser:parse(Tokens) of

lib/elixir/src/elixir.hrl

@@ -16,7 +16,8 @@
   export_vars=nil,         %% a dict of all variables defined in a particular clause
   extra_guards=nil,        %% extra guards from args expansion
   counter=#{},             %% a map counting the variables defined
-  file=(<<"nofile">>)      %% the current scope filename
+  file=(<<"nofile">>),     %% the current scope filename
+  safe_by_default=false    %% if case/cond/receive variables should be marked as safe by default
 }).
 
 -record(elixir_quote, {
@@ -28,8 +29,7 @@
   imports_hygiene=true,
   unquote=true,
   unquoted=false,
-  escape=false,
-  generated=false
+  escape=false
 }).
 
 -record(elixir_tokenizer, {