Merge pull request 'adapter: support OpenAI streaming (SSE) in /v1/chat/completions' (#1) from feat/adapter-streaming into main

OpenCode's @ai-sdk/openai-compatible sends stream:true and would render an
empty response because the adapter always returned a single non-streaming
chat.completion JSON body. Now when stream:true, emit OpenAI-compatible SSE
chat.completion.chunk events (role, content, [DONE]) so streaming clients
render text. Non-streaming path unchanged.

Adds a local EchoServer test that exercises the streaming route end-to-end.

.appveyor.yml

@@ -1,9 +0,0 @@
-version: 1-{branch}+{build}
-
-build_script:
-  - cmd: C:\MinGW\msys\1.0\bin\make
-  - cmd: rmdir /s /q .git
-before_test:
-  - cmd: set PATH=%PATH%;C:\Program Files\erl8.3\erts-8.3\bin
-test_script:
-  - cmd: C:\MinGW\msys\1.0\bin\make --keep-going test_windows

.gitattributes

@@ -1 +0,0 @@
-lib/elixir/test/elixir/fixtures/*.txt text eol=lf

.gitignore

@@ -1,14 +1,11 @@
+.formatter.exs
+/_build/
+/cover/
+/deps/
 /doc/
-/lib/*/ebin/
-/lib/*/_build/
-/lib/*/tmp/
-/lib/elixir/src/*_parser.erl
-/lib/elixir/src/elixir.app.src
-/lib/elixir/test/ebin/
-/man/elixir.1
-/man/iex.1
-/Docs-v*.zip
-/Precompiled-v*.zip
-/.eunit
-.elixir.plt
+/.fetch
 erl_crash.dump
+*.ez
+n8n_openai_adapter-*.tar
+/tmp/
+/result

.travis.yml

@@ -1,32 +0,0 @@
-language: erlang
-sudo: false
-
-os: linux
-otp_release: 18.0
-
-matrix:
-  include:
-    - os: linux
-      otp_release: 18.1
-    - os: linux
-      otp_release: 18.2
-    - os: linux
-      otp_release: 18.3
-    - os: linux
-      otp_release: 19.0
-    - os: linux
-      otp_release: 19.1
-    - os: linux
-      otp_release: 19.2
-    - os: linux
-      otp_release: 19.3
-    - os: linux
-      otp_release: 20.0
-
-script: "make compile && rm -rf .git && make test"
-
-notifications:
-  recipients:
-    - jose.valim@plataformatec.com.br
-    - eric.meadows.jonsson@gmail.com
-

CHANGELOG.md

@@ -1,311 +0,0 @@
-# Changelog for Elixir v1.5
-
-Elixir v1.5 brings new features, enhancements and bug fixes to Elixir. It is the first release to leverage features added as part of Erlang/OTP 20. It is also the last release that supports Erlang/OTP 18.
-
-## UTF-8 atoms, function names and variables
-
-Elixir v1.5 supports non-quoted atoms and variables to be in UTF-8 when using Erlang/OTP 20+. For example:
-
-    test "こんにちは世界" do
-      assert :こんにちは世界
-    end
-
-Or:
-
-    saudação = "Bom dia!"
-
-Elixir follows the recommendations in [Unicode Annex #31](http://unicode.org/reports/tr31/) to make the language more accessible to other languages and communities. Identifiers must still be a sequence of letters, followed by digits and combining marks. This means symbols, such as mathematical notations and emoji, are not allowed identifiers.
-
-For a complete reference on Elixir syntax, see the [Syntax Reference](https://hexdocs.pm/elixir/syntax-reference.html). For technical details on Unicode support, see [Unicode Syntax](https://hexdocs.pm/elixir/unicode-syntax.html).
-
-## IEx improvements
-
-IEx got many improvements. The autocompletion system is now capable of autocompleting variables and user imports. New helpers have also been added:
-
-  * `exports/1` lists all exports (functions and macros) in a given module
-  * `open/1` opens up the source of a module or function directly in your editor. For example, `open MyApp.Module`
-  * `runtime_info/0` prints general information about the running system, such as number of cores, runtime version, allocation of memory in the VM and more
-
-IEx also features a breakpoint system for code debugging. The following functions have been added to aid debugging:
-
-  * `break!/2` - sets up a breakpoint for a given `Mod.fun/arity`
-  * `break!/4` - sets up a breakpoint for the given module, function, arity
-  * `breaks/0` - prints all breakpoints and their ids
-  * `continue/0` - continues until the next breakpoint in the same process
-  * `open/0` - opens editor on the current breakpoint
-  * `remove_breaks/0` - removes all breakpoints in all modules
-  * `remove_breaks/1` - removes all breakpoints in a given module
-  * `reset_break/1` - sets the number of stops on the given id to zero
-  * `reset_break/3` - sets the number of stops on the given module, function, arity to zer
-  * `respawn/0` - starts a new shell (breakpoints will ask for permission once more)
-  * `whereami/1` - shows the current location
-
-## Exception.blame
-
-`Exception.blame/3` is a new function in Elixir that is capable of attaching debug information to certain exceptions. Currently this is used to augment `FunctionClauseError`s with a summary of all clauses and which parts of clause match and which ones didn't. For example:
-
-    iex> Access.fetch(:foo, :bar)
-    ** (FunctionClauseError) no function clause matching in Access.fetch/2
-
-    The following arguments were given to Access.fetch/2:
-
-        # 1
-        :foo
-
-        # 2
-        :bar
-
-    Attempted function clauses (showing 5 out of 5):
-
-        def fetch(-%struct{} = container-, key)
-        def fetch(map, key) when -is_map(map)-
-        def fetch(list, key) when -is_list(list)- and is_atom(key)
-        def fetch(list, key) when -is_list(list)-
-        def fetch(-nil-, _key)
-
-    (elixir) lib/access.ex:261: Access.fetch/2
-
-In the example above, an argument that did not match or guard that did not evaluate to true are shown between `-`. If the terminal supports ANSI coloring, they are wrapped in red instead of the `-` character.
-
-Since blaming an exception can be expensive, `Exception.blame/3` must be used exclusively in debugging situations. It is not advised to apply it to production components such as a Logger. This feature has been integrated into the compiler, the command line, ExUnit and IEx.
-
-This feature also requires Erlang/OTP 20+.
-
-## Streamlined child specs
-
-Elixir v1.5 streamlines how supervisors are defined and used in Elixir. Elixir now allows child specifications, which specify how a child process is supervised, to be defined in modules. In previous versions, a project using Phoenix would write:
-
-    import Supervisor.Spec
-
-    children = [
-      supervisor(MyApp.Repo, []),
-      supervisor(MyApp.Endpoint, [])
-    ]
-
-    Supervisor.start_link(children, strategy: :one_for_one)
-
-In Elixir v1.5, one might do:
-
-    children = [
-      MyApp.Repo,
-      MyApp.Endpoint
-    ]
-
-    Supervisor.start_link(children, strategy: :one_for_one)
-
-The above works by calling the `child_spec/1` function on the given modules.
-
-This new approach allows `MyApp.Repo` and `MyApp.Endpoint` to control how they run under a supervisor. This reduces the chances of mistakes being made, such as starting an Ecto repository as a worker or forgetting to declare that tasks are temporary in a supervision tree.
-
-If it is necessary to configure any of the children, such can be done by passing a tuple instead of an atom:
-
-    children = [
-      {MyApp.Repo, url: "ecto://localhost:4567/my_dev"},
-      MyApp.Endpoint
-    ]
-
-The modules `Agent`, `Registry`, `Task`, and `Task.Supervisor` have been updated to include a `child_spec/1` function, allowing them to be used directly in a supervision tree similar to the examples above. `use Agent`, `use GenServer`, `use Supervisor`, and `use Task` have also been updated to automatically define an overridable `child_spec/1` function.
-
-Finally, child specifications are now provided as maps (data-structures) instead of the previous `Supervisor.Spec.worker/3` and `Supervisor.Spec.supervisor/3` APIs. This behaviour also aligns with how supervisors are configured in Erlang/OTP 18+. See the updated `Supervisor` docs for more information, as well as the new `Supervisor.init/2` and `Supervisor.child_spec/2` functions.
-
-## @impl
-
-This release also allows developers to mark which functions in a given module are an implementation of a callback. For example, when using the [Plug](https://github.com/elixir-lang/plug) project, one needs to implement both `init/1` and `call/2` when writing a Plug:
-
-    defmodule MyApp do
-      @behaviour Plug
-
-      def init(_opts) do
-        opts
-      end
-
-      def call(conn, _opts) do
-        Plug.Conn.send_resp(conn, 200, "hello world")
-      end
-    end
-
-The problem with the approach above is that, once more and more functions are added to the `MyApp` module, it becomes increasingly harder to know the purposes of the `init/1` and `call/2` functions. For example, for a developer unfamiliar with Plug, are those functions part of the `MyApp` API or are they implementations of a given callback?
-
-Elixir v1.5 introduces the `@impl` attribute, which allows us to mark that certain functions are implementation of callbacks:
-
-    defmodule MyApp do
-      @behaviour Plug
-
-      @impl true
-      def init(_opts) do
-        opts
-      end
-
-      @impl true
-      def call(conn, _opts) do
-        Plug.Conn.send_resp(conn, 200, "hello world")
-      end
-    end
-
-You may even use `@impl Plug` if you want to explicitly document which behaviour defines the callback you are implementing.
-
-Overall, using `@impl` has the following advantages:
-
-  * Readability of the code is increased, as it is now clear which functions are part of your API and which ones are callback implementations. To reinforce this idea, `@impl true` automatically marks the function as `@doc false`, disabling documentation unless `@doc` is explicitly set
-
-  * If you define `@impl` before a function that is not a callback, Elixir will error. This is useful in case of typos or in case the behaviour definition changes (such as a new major version of a library you depend on is released)
-
-  * If you use `@impl` in one implementation, Elixir will force you to declare `@impl` for all other implementations in the same module, keeping your modules consistent
-
-## Calendar improvements
-
-This release brings further improvements to Calendar types. It adds arithmetic and others functions to `Time`, `Date`, `NaiveDateTime` and `Datetime` as well as conversion between different calendars.
-
-## v1.5.0 (2017-07-25)
-
-### 1. Enhancements
-
-#### Elixir
-
-  * [Access] Optimize `Access.get/2`
-  * [Base] Optimise Base encode/decode
-  * [Calendar] Implement Inspect for DateTime with Calendar.ISO
-  * [Calendar] Add "ISO days" format for conversions between Calendars and `Date.convert/2`, `Time.convert/2`, `NaiveDateTime.convert/2` and `DateTime.convert/2` (as well as bang variants)
-  * [Calendar] Add `:calendar` field to `Time` struct
-  * [Calendar] Add `Time.diff/3`, `Date.add/2`, `Date.diff/2`, `DateTime.diff/3`
-  * [Calendar] Add `Date.range/2`
-  * [Calendar] Add `Date.new/4`, `DateTime.utc_now/1`, `NaiveDateTime.new/8` and `Time.new/5` that allow specifing calendar
-  * [Enum] Add `Enum.chunk_by/4` and `Stream.chunk_by/4`
-  * [Enum] Add `Enum.chunk_every/2` and `Enum.chunk_every/4` with a more explicit API than `Enum.chunk/2` and `Enum.chunk/4`
-  * [Exception] Add `Exception.blame/3` that adds metadata to exceptions
-  * [File] Add `File.read_link/1` and `File.read_link!/1`
-  * [File] Introduce `:trim_bom` option for `File.stream!/2`
-  * [Inspect] Add `:printable_limit` to control the limit of printable structures
-  * [Integer] Add `Integer.gcd/2`
-  * [Kernel] Add `left not in right` to check that the left side is not in the enumerable on the right
-  * [Kernel] Use the new `debug_info` chunk in OTP 20. This provides a mechanism for tools to retrieve the Elixir AST from beam files
-  * [Kernel] `defoverridable/1` accepts a module name as argument and marks all callbacks as overridable
-  * [Kernel] Allow non-quoted Unicode atoms and variables according to Unicode Annex #31 (see Unicode Syntax document)
-  * [Kernel] Warn when a `:__struct__` key is used when building/updating structs
-  * [Kernel] Cache the AST on definitions. This speeds up the compilation time from 10% to 15% measured across different projects
-  * [Kernel] Improve compiler error message on invalid patterns and guards
-  * [Keyword] Add `replace/3` and `replace!/3` for replacing an existing key
-  * [List] `List.starts_with?/2`
-  * [Macro] Introduce `Macro.generate_arguments/2`
-  * [Map] Optimize `Map.merge/3` by choosing merging direction
-  * [Map] Add `replace/3` and `replace!/3` for replacing an existing key
-  * [Map] Raise `BadMapError` in `Map.equal?/2` when either of the two arguments is not a map
-  * [MapSet] Reduce `MapSet` size when serialized to approximately half
-  * [Process] Add `Process.cancel_timer/2`
-  * [Protocol] Show available implementations on `Protocol.UndefinedError` if the protocol has been consolidated
-  * [Registry] Support ETS guard conditions in `Registry.match/3`
-  * [Registry] Support `parallel: true` in `Registry.dispatch/3`
-  * [Registry] Introduce `Registry.unregister_match/4`
-  * [Stream] Add `Stream.chunk_every/2` and `Stream.chunk_every/4` with a more explicit API than `Stream.chunk/2` and `Stream.chunk/4`
-  * [String] Optimise binary pattern matching in `String.split/1` and `String.trim_*/1`
-  * [Supervisor] Add `Supervisor.init/2` and `Supervisor.child_spec/2`
-  * [Supervisor] Allow `module` and `{module, arg}` to be given to `Supervisor.start_link/2` and invoke `module.child_spec(arg)` on each argument
-  * [Task] Support `:on_timeout` in `Task.async_stream` to control how tasks are terminated
-  * [Task] Add `ordered: false` support to `Task.async_stream`
-
-#### ExUnit
-
-  * [ExUnit] Show code snippet from test source file in case of test errors
-  * [ExUnit] Use `Exception.blame/3` when formatting test errors
-  * [ExUnit] Make `assert_raise/2` fail if the underlying exception has a broken `message/1` implementation
-  * [ExUnit] Add `start_supervised/2` and `stop_supervised/1` to ExUnit. Processes started by this function are automatically shut down when the test exits
-
-#### IEx
-
-  * [IEx.Autocomplete] Support autocompletion of variable names
-  * [IEx.Autocomplete] Support autocompletion of functions imported using `import Mod, only: [...]`
-  * [IEx.Evaluator] Use `Exception.blame/3` when showing errors in the terminal
-  * [IEx.Helpers] Add `exports/1` IEx helper to list all exports in a module
-  * [IEx.Helpers] Add `break!/2`, `break!/4`, `breaks/0`, `continue/0`, `open/0`, `remove_breaks/0`, `remove_breaks/1`, `reset_break/1`, `reset_break/3` and `whereami/1` for code debugging
-  * [IEx.Helpers] No longer emit warnings for IEx commands without parentheses
-  * [IEx.Helpers] Add `runtime_info/0` for printing runtime system information
-  * [IEx.Helpers] Add `open/1` to open the source of a given module/function in your editor
-  * [IEx.Info] Implement `IEx.Info` protocol for calendar types
-
-#### Logger
-
-  * [Logger] Add `metadata: :all` configuration to log all metadata
-
-#### Mix
-
-  * [mix compile.elixir] Add `--all-warnings` option to Elixir compiler that shows all warnings from the previous compilation (instead of just of the files being compiled)
-  * [mix escript.build] Strip debug information from escripts by default and add option `:strip_beam` which defaults to true
-  * [mix loadpaths] Ensure `--no-deps-check` do not trigger SCM callbacks (such as `git`)
-  * [mix local.hex] Add `--if-missing` flag to `local.hex` mix task
-  * [mix profile.cprof] Add `Mix.Tasks.Profile.Cprof` for count-based profiling
-  * [mix new] New styling for generated applications
-
-### 2. Bug fixes
-
-#### Elixir
-
-  * [Calendar] Ensure `Calendar.ISO` raises a readable error when reaching up the year 10000 restriction
-  * [Calendar] Return `{:error, :invalid_time}` for wrong precision instead of crashing when parsing ISO dates
-  * [Enumerable] Raise `Protocol.UndefinedError` on bad functions in Enumerable implementation
-  * [File] Ensure recursive file operations raise on paths with null bytes (*security issue reported by Griffin Byatt*)
-  * [File] Support `:ram`/`:raw` files in `File.copy/2`
-  * [Inspect] Do not use colors when inspecting error messages
-  * [Kernel] Support guards on anonymous functions of zero arity
-  * [Kernel] Fix compilation of maps used as maps keys inside matches
-  * [Kernel] Ensure `do` clause in `with` is tail call optimizable
-  * [Module] `on_definition/6` callback receives body wrapped in a keyword list, such as `[do: body]`. This solves a bug where it was impossible to distinguish between a bodyless clause and a function that returns `nil`.
-  * [Path] Ensure recursive path operations raise on paths with null bytes (*security issue reported by Griffin Byatt*)
-  * [Protocol] Do not lose source compile info on protocol consolidation
-  * [Record] Properly escape quoted expressions passed to `defrecord`
-  * [Regex] Fix `inspect/2` for regexes with `/` terminator in them
-  * [Registry] Ensure `Registry.match/4` works with `:_` as key
-  * [Stream] Fix stream cycle over empty enumerable
-  * [String] Consider Unicode non-characters valid according to the specification in `String.valid?/1`
-  * [StringIO] Fix encoding and performance issues in `StringIO.get_until`
-  * [System] Raise on paths with null bytes in `System.cmd/2` and in `System.find_executable/1` (*security issue reported by Griffin Byatt*)
-  * [System] Raise on ill-formed environment variables (*security issue reported by Griffin Byatt*)
-
-#### ExUnit
-
-  * [ExUnit] Properly account failed tests when `setup_all` fails
-
-#### IEx
-
-  * [IEx] Skip autocompletion of module names that are invalid without being quoted
-  * [IEx] Skip autocompletion of functions with default arguments with `@doc false`
-  * [IEx] Do not start oldshell alongside IEx
-
-#### Mix
-
-  * [mix compile.elixir] Store multiple sources in case of module conflicts. This solves an issue where `_build` would get corrupted when compiling Elixir projects with module conflicts
-  * [mix compile.erlang] Do not silently discard Erlang compile errors
-  * [mix compile.erlang] Properly track `-compile` module attribute when specified as a list
-  * [mix compile.protocols] Ensure protocol implementations do not "disappear" when switching between applications in umbrella projects by having separate consolidation paths per project
-  * [mix compile.protocols] Do not raise when consolidating a protocol that was converted into a module
-
-### 3. Soft deprecations (no warnings emitted)
-
-#### Elixir
-
-  * [Kernel] `not left in right` is soft-deprecated in favor of `left not in right`
-
-### 4. Deprecations
-
-#### Elixir
-
-  * `Atom.to_char_list/1`, `Float.to_char_list/1`, `Integer.to_char_list/1`, `Integer.to_char_list/2`, `Kernel.to_char_list/1`, `List.Chars.to_char_list/1`, `String.to_char_list/1` have been deprecated in favor of their `to_charlist` version. This aligns with the naming conventions in both Erlang and Elixir
-  * [Enum] Deprecate `Enum.filter_map/3` in favor of `Enum.filter/2` + `Enum.map/2` or for-comprehensions
-  * [GenEvent] Deprecate `GenEvent` and provide alternatives in its docs
-  * [Kernel] Using `()` to mean `nil` is deprecated
-  * [Kernel] `:as_char_lists value` in `Inspect.Opts.t/0` type, in favor of `:as_charlists`
-  * [Kernel] `:char_lists` key in `Inspect.Opts.t/0` type, in favor of `:charlists`
-  * [Module] Using Erlang parse transforms via `@compile {:parse_transform, _}` is deprecated
-  * [Stream] Deprecate `Stream.filter_map/3` in favor of `Stream.filter/2` + `Stream.map/2`
-  * [String] `String.ljust/3` and `String.rjust/3` are deprecated in favor of `String.pad_leading/3` and `String.pad_trailing/3` with a binary padding
-  * [String] `String.strip/1` and `String.strip/2` are deprecated in favor of `String.trim/1` and `String.trim/2`
-  * [String] `String.lstrip/1` and `String.rstrip/1` are deprecated in favor of `String.trim_leading/1` and `String.trim_trailing/1`
-  * [String] `String.lstrip/2` and `String.rstrip/2` are deprecated in favor of `String.trim_leading/2` and `String.trim_trailing/2` with a binary as second argument
-  * [Typespec] `char_list/0` type is deprecated in favor of `charlist/0`
-
-#### EEx
-
-  * [EEx] Deprecate `<%= ` in "middle" and "end" expressions, e.g.: `<%= else %>` and `<%= end %>`
-
-## v1.4
-
-The CHANGELOG for v1.4 releases can be found [in the v1.4 branch](https://github.com/elixir-lang/elixir/blob/v1.4/CHANGELOG.md).

CODE_OF_CONDUCT.md

@@ -1,56 +0,0 @@
-# Code of Conduct
-
-Contact: elixir-lang-conduct@googlegroups.com
-
-## Why have a Code of Conduct?
-
-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.
-
-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.
-
-## Our Values
-
-These are the values Elixir developers should aspire to:
-
-  * 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).
-
-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.

ISSUE_TEMPLATE.md

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

LICENSE

@@ -1,13 +0,0 @@
-Copyright 2012 Plataformatec
-
-  Licensed under the Apache License, Version 2.0 (the "License");
-  you may not use this file except in compliance with the License.
-  You may obtain a copy of the License at
-
-      http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing, software
-  distributed under the License is distributed on an "AS IS" BASIS,
-  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-  See the License for the specific language governing permissions and
-  limitations under the License.

Makefile

@@ -1,275 +0,0 @@
-REBAR ?= "$(CURDIR)/rebar"
-PREFIX ?= /usr/local
-SHARE_PREFIX ?= $(PREFIX)/share
-CANONICAL := v1.5/
-ELIXIRC := bin/elixirc --verbose --ignore-module-conflict
-ERLC := erlc -I lib/elixir/include
-ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
-VERSION := $(strip $(shell cat VERSION))
-Q := @
-LIBDIR := lib
-BINDIR := bin
-INSTALL = install
-INSTALL_DIR = $(INSTALL) -m755 -d
-INSTALL_DATA = $(INSTALL) -m644
-INSTALL_PROGRAM = $(INSTALL) -m755
-GIT_REVISION = $(strip $(shell git rev-parse HEAD 2> /dev/null ))
-GIT_TAG = $(strip $(shell head="$(call GIT_REVISION)"; git tag --points-at $$head 2> /dev/null | tail -1) )
-
-.PHONY: install compile erlang elixir build_plt clean_plt dialyze test clean clean_residual_files install_man clean_man docs Docs.zip Precompiled.zip zips
-.NOTPARALLEL: compile
-
-#==> Functions
-
-define CHECK_ERLANG_RELEASE
-	$(Q) erl -noshell -eval '{V,_} = string:to_integer(erlang:system_info(otp_release)), io:fwrite("~s", [is_integer(V) and (V >= 18)])' -s erlang halt | grep -q '^true'; \
-		if [ $$? != 0 ]; then \
-		  echo "At least Erlang 18.0 is required to build Elixir"; \
-		  exit 1; \
-		fi;
-endef
-
-define APP_TEMPLATE
-$(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app
-
-lib/$(1)/ebin/$(1).app: lib/$(1)/mix.exs
-	$(Q) mkdir -p lib/$(1)/_build/shared/lib/$(1)
-	$(Q) cp -R lib/$(1)/ebin lib/$(1)/_build/shared/lib/$(1)/
-	$(Q) cd lib/$(1) && ../../bin/elixir -e 'Mix.start(:permanent, [])' -r mix.exs -e 'Mix.Task.run("compile.app")'
-	$(Q) cp lib/$(1)/_build/shared/lib/$(1)/ebin/$(1).app lib/$(1)/ebin/$(1).app
-	$(Q) rm -rf lib/$(1)/_build
-
-lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)
-	@ echo "==> $(1) (compile)"
-	@ rm -rf lib/$(1)/ebin
-	$(Q) cd lib/$(1) && ../../$$(ELIXIRC) "lib/**/*.ex" -o ebin
-
-test_$(1): compile $(1)
-	@ echo "==> $(1) (exunit)"
-	$(Q) cd lib/$(1) && ../../bin/elixir -r "test/test_helper.exs" -pr "test/**/*_test.exs";
-endef
-
-#==> Compilation tasks
-
-KERNEL:=lib/elixir/ebin/Elixir.Kernel.beam
-UNICODE:=lib/elixir/ebin/Elixir.String.Unicode.beam
-
-default: compile
-
-compile: lib/elixir/src/elixir.app.src erlang elixir
-
-lib/elixir/src/elixir.app.src: src/elixir.app.src
-	$(Q) $(call CHECK_ERLANG_RELEASE)
-	$(Q) rm -f lib/elixir/src/elixir.app.src
-	$(Q) echo "%% This file is automatically generated from <project_root>/src/elixir.app.src" \
-	          >lib/elixir/src/elixir.app.src
-	$(Q) cat src/elixir.app.src >>lib/elixir/src/elixir.app.src
-
-erlang:
-	$(Q) cd lib/elixir && $(REBAR) compile
-
-# Since Mix depends on EEx and EEx depends on Mix,
-# we first compile EEx without the .app file,
-# then mix and then compile EEx fully
-elixir: stdlib lib/eex/ebin/Elixir.EEx.beam mix ex_unit logger eex iex
-
-stdlib: $(KERNEL) VERSION
-$(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex lib/elixir/lib/*/*/*.ex
-	$(Q) if [ ! -f $(KERNEL) ]; then \
-		echo "==> bootstrap (compile)"; \
-		$(ERL) -s elixir_compiler bootstrap -s erlang halt; \
-	fi
-	@ echo "==> elixir (compile)";
-	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/kernel.ex" -o ebin;
-	$(Q) cd lib/elixir && ../../$(ELIXIRC) "lib/**/*.ex" -o ebin;
-	$(Q) $(MAKE) unicode
-	$(Q) rm -f lib/elixir/ebin/elixir.app
-	$(Q) cd lib/elixir && $(REBAR) compile
-
-unicode: $(UNICODE)
-$(UNICODE): lib/elixir/unicode/*
-	@ echo "==> unicode (compile)";
-	$(Q) $(ELIXIRC) lib/elixir/unicode/unicode.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/properties.ex -o lib/elixir/ebin;
-	$(Q) $(ELIXIRC) lib/elixir/unicode/tokenizer.ex -o lib/elixir/ebin;
-
-$(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
-$(eval $(call APP_TEMPLATE,logger,Logger))
-$(eval $(call APP_TEMPLATE,eex,EEx))
-$(eval $(call APP_TEMPLATE,mix,Mix))
-$(eval $(call APP_TEMPLATE,iex,IEx))
-
-install: compile
-	@ echo "==> elixir (install)"
-	$(Q) for dir in lib/*; do \
-		rm -rf $(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin; \
-		$(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
-		$(INSTALL_DATA) $$dir/ebin/* "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/$$dir/ebin"; \
-	done
-	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
-	$(Q) $(INSTALL_PROGRAM) $(filter-out %.ps1, $(filter-out %.bat, $(wildcard bin/*))) "$(DESTDIR)$(PREFIX)/$(LIBDIR)/elixir/bin"
-	$(Q) $(INSTALL_DIR) "$(DESTDIR)$(PREFIX)/$(BINDIR)"
-	$(Q) for file in "$(DESTDIR)$(PREFIX)"/$(LIBDIR)/elixir/bin/*; do \
-		ln -sf "../$(LIBDIR)/elixir/bin/$${file##*/}" "$(DESTDIR)$(PREFIX)/$(BINDIR)/"; \
-	done
-	$(MAKE) install_man
-
-clean:
-	cd lib/elixir && $(REBAR) clean
-	rm -rf ebin
-	rm -rf lib/*/ebin
-	rm -f lib/elixir/src/elixir.app.src
-	$(Q) $(MAKE) clean_residual_files
-
-clean_elixir:
-	$(Q) rm -f lib/*/ebin/Elixir.*.beam
-
-clean_residual_files:
-	rm -rf lib/*/_build/
-	rm -rf lib/*/tmp/
-	rm -rf lib/elixir/test/ebin/
-	rm -rf lib/mix/test/fixtures/deps_on_git_repo/
-	rm -rf lib/mix/test/fixtures/git_rebar/
-	rm -rf lib/mix/test/fixtures/git_repo/
-	rm -rf lib/mix/test/fixtures/git_sparse_repo/
-	rm -f erl_crash.dump
-	$(Q) $(MAKE) clean_man
-
-#==> Documentation tasks
-
-LOGO_PATH = $(shell test -f ../docs/logo.png && echo "--logo ../docs/logo.png")
-SOURCE_REF = $(shell tag="$(call GIT_TAG)" revision="$(call GIT_REVISION)"; echo "$${tag:-$$revision}\c")
-DOCS_FORMAT = html
-COMPILE_DOCS = bin/elixir ../ex_doc/bin/ex_doc "$(1)" "$(VERSION)" "lib/$(2)/ebin" -m "$(3)" -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)" $(call LOGO_PATH) -o doc/$(2) -n https://hexdocs.pm/$(2)/$(CANONICAL) -p http://elixir-lang.org/docs.html -f "$(DOCS_FORMAT)" $(4)
-
-docs: compile ../ex_doc/bin/ex_doc docs_elixir docs_eex docs_mix docs_iex docs_ex_unit docs_logger
-
-docs_elixir: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (elixir)"
-	$(Q) rm -rf doc/elixir
-	$(call COMPILE_DOCS,Elixir,elixir,Kernel,-e "lib/elixir/pages/Behaviours.md" -e "lib/elixir/pages/Deprecations.md" -e "lib/elixir/pages/Guards.md" -e "lib/elixir/pages/Naming Conventions.md" -e "lib/elixir/pages/Operators.md" -e "lib/elixir/pages/Syntax Reference.md" -e "lib/elixir/pages/Typespecs.md" -e "lib/elixir/pages/Unicode Syntax.md" -e "lib/elixir/pages/Writing Documentation.md")
-
-docs_eex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (eex)"
-	$(Q) rm -rf doc/eex
-	$(call COMPILE_DOCS,EEx,eex,EEx)
-
-docs_mix: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (mix)"
-	$(Q) rm -rf doc/mix
-	$(call COMPILE_DOCS,Mix,mix,Mix)
-
-docs_iex: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (iex)"
-	$(Q) rm -rf doc/iex
-	$(call COMPILE_DOCS,IEx,iex,IEx)
-
-docs_ex_unit: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (ex_unit)"
-	$(Q) rm -rf doc/ex_unit
-	$(call COMPILE_DOCS,ExUnit,ex_unit,ExUnit)
-
-docs_logger: compile ../ex_doc/bin/ex_doc
-	@ echo "==> ex_doc (logger)"
-	$(Q) rm -rf doc/logger
-	$(call COMPILE_DOCS,Logger,logger,Logger)
-
-../ex_doc/bin/ex_doc:
-	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
-	@ false
-
-#==> Zip tasks
-
-Docs.zip: docs
-	rm -f Docs-v$(VERSION).zip
-	zip -9 -r Docs-v$(VERSION).zip CHANGELOG.md doc NOTICE LICENSE README.md
-	@ echo "Docs file created $(CURDIR)/Docs-v$(VERSION).zip"
-
-Precompiled.zip: build_man compile
-	rm -f Precompiled-v$(VERSION).zip
-	zip -9 -r Precompiled-v$(VERSION).zip bin CHANGELOG.md lib/*/ebin LICENSE man NOTICE README.md VERSION
-	@ echo "Precompiled file created $(CURDIR)/Precompiled-v$(VERSION).zip"
-
-zips: Precompiled.zip Docs.zip
-
-#==> Test tasks
-
-test: test_erlang test_elixir
-
-test_windows: test test_taskkill
-
-test_taskkill:
-	taskkill //IM erl.exe //F //T //FI "MEMUSAGE gt 0"
-	taskkill //IM epmd.exe //F //T //FI "MEMUSAGE gt 0"
-
-TEST_ERL = lib/elixir/test/erlang
-TEST_EBIN = lib/elixir/test/ebin
-TEST_ERLS = $(addprefix $(TEST_EBIN)/, $(addsuffix .beam, $(basename $(notdir $(wildcard $(TEST_ERL)/*.erl)))))
-
-test_erlang: compile $(TEST_ERLS)
-	@ echo "==> elixir (eunit)"
-	$(Q) $(ERL) -pa $(TEST_EBIN) -s test_helper test;
-	@ echo ""
-
-$(TEST_EBIN)/%.beam: $(TEST_ERL)/%.erl
-	$(Q) mkdir -p $(TEST_EBIN)
-	$(Q) $(ERLC) -o $(TEST_EBIN) $<
-
-test_elixir: test_stdlib test_ex_unit test_logger test_mix test_eex test_iex
-
-test_stdlib: compile
-	@ echo "==> elixir (exunit)"
-	$(Q) exec epmd & exit
-	$(Q) if [ "$(OS)" = "Windows_NT" ]; then \
-		cd lib/elixir && cmd //C call ../../bin/elixir.bat -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs"; \
-	else \
-		cd lib/elixir && ../../bin/elixir -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs"; \
-	fi
-
-#==> Dialyzer tasks
-
-DIALYZER_OPTS = --no_check_plt --fullpath -Werror_handling -Wunmatched_returns -Wunderspecs
-PLT = .elixir.plt
-
-$(PLT):
-	@ echo "==> Building PLT with Elixir's dependencies..."
-	$(Q) dialyzer --output_plt $(PLT) --build_plt --apps erts kernel stdlib compiler syntax_tools parsetools tools ssl inets
-
-clean_plt:
-	$(Q) rm -f $(PLT)
-
-build_plt: clean_plt $(PLT)
-
-dialyze: compile $(PLT)
-	@ echo "==> Dialyzing Elixir..."
-	$(Q) dialyzer --plt $(PLT) $(DIALYZER_OPTS) lib/*/ebin
-
-#==> Man page tasks
-
-build_man: man/iex.1 man/elixir.1
-
-man/iex.1:
-	$(Q) cp man/iex.1.in man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/r common" man/iex.1
-	$(Q) sed -i.bak "/{COMMON}/d" man/iex.1
-	$(Q) rm -f man/iex.1.bak
-
-man/elixir.1:
-	$(Q) cp man/elixir.1.in man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/r common" man/elixir.1
-	$(Q) sed -i.bak "/{COMMON}/d" man/elixir.1
-	$(Q) rm -f man/elixir.1.bak
-
-clean_man:
-	rm -f man/elixir.1
-	rm -f man/elixir.1.bak
-	rm -f man/iex.1
-	rm -f man/iex.1.bak
-
-install_man: build_man
-	$(Q) mkdir -p $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/elixir.1  $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/elixirc.1 $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/iex.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(Q) $(INSTALL_DATA) man/mix.1     $(DESTDIR)$(SHARE_PREFIX)/man/man1
-	$(MAKE) clean_man

NOTICE

@@ -1,22 +0,0 @@
-LEGAL NOTICE INFORMATION
-------------------------
-
-All the files in this distribution are copyright (c) 2012 Plataformatec
-covered under Elixir's license (see the file LICENSE) except the cases
-below.
-
-== lib/elixir/src/elixir_parser.erl (generated by build scripts)
-
-Copyright Ericsson AB 1996-2015
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

README.md

@@ -1,183 +1,94 @@
-![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
-=========
-[![Travis build](https://secure.travis-ci.org/elixir-lang/elixir.svg?branch=master
-"Build Status")](https://travis-ci.org/elixir-lang/elixir)
-[![Windows build](https://ci.appveyor.com/api/projects/status/macwuxq7aiiv61g1?svg=true)](https://ci.appveyor.com/project/josevalim/elixir)
+# n8n-openai-adapter
 
+An OpenAI-compatible HTTP adapter that exposes self-hosted **n8n chat agents**
+behind a standard `/v1/chat/completions` API, so any OpenAI client (Cursor,
+LibreChat, the `openai` SDK, a custom app) can talk to your n8n agents as if
+they were OpenAI models.
 
-Elixir is a dynamic, functional language designed for building scalable and maintainable applications.
+n8n itself does **not** ship an inbound OpenAI-compatible endpoint (its "AI
+Gateway" is an outbound proxy to n8n Cloud). This small Elixir service is the
+bridge: one `/v1/chat/completions` endpoint, routed to whichever n8n agent you
+name in the `model` field.
 
-For more about Elixir, installation and documentation,
-[check Elixir's website](http://elixir-lang.org/).
+## How it works
 
-## Compiling from source
-
-To run Elixir from source, clone this repository to your machine, compile and test it:
-
-```sh
-git clone https://github.com/elixir-lang/elixir.git
-cd elixir
-make clean test
+```
+Your OpenAI client
+   POST /v1/chat/completions {"model":"scholar-agent","thread_id":"abc","messages":[...]}
+        |
+        v
+   n8n-openai-adapter (Plug + Bandit)
+     - authorize (Bearer <ADAPTER_API_KEY>)
+     - look up "scholar-agent" -> n8n chat webhook URL (AgentRegistry GenServer)
+     - take the last user message
+     - forward to the n8n webhook {sessionId: thread_id, action: sendMessage, chatInput}
+        |
+        v
+   n8n agent (its MCP tools, memory, etc. run as usual)
+        |
+        v
+   returns OpenAI-shaped {"choices":[{"message":{"role":"assistant","content":...}}]}
 ```
 
-> Note: if you are running on Windows,
-[this article includes important notes for compiling Elixir from source
-on Windows](https://github.com/elixir-lang/elixir/wiki/Windows).
+Multiple agents = multiple `model` names, each mapped to a different n8n webhook
+in the `AGENTS` env var.
 
-If Elixir fails to build (specifically when pulling in a new version via
-`git`), be sure to remove any previous build artifacts by running
-`make clean`, then `make test`.
+## Configuration (env vars)
 
-If tests pass, you are ready to move on to the [Getting Started guide][1]
-or to try Interactive Elixir by running `bin/iex` in your terminal.
+| Var              | Required | Purpose                                                            |
+|------------------|----------|---------------------------------------------------------------------|
+| `ADAPTER_API_KEY`| yes      | Bearer key that OpenAI clients send.                                |
+| `ADMIN_API_KEY`  | yes      | Bearer key for the admin API / web admin page.                      |
+| `AGENTS_FILE`    | no       | Path to the JSON store (default `/var/lib/n8n-openai/agents.json`). |
+| `PORT`           | no       | HTTP port (default `8000`).                                         |
+| `CHAT_WEBHOOK_BASIC` | no   | `"user:password"` if your n8n Chat Trigger is Basic-auth protected. |
 
-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:
+Agents are **not** configured via env — they're managed at runtime through the
+web admin page / admin API and persisted to `AGENTS_FILE`. The store starts
+empty; add agents after boot.
 
-    Erlang/OTP 18 [erts-7.0] [source] [smp:2:2] [async-threads:10] [hipe] [kernel-poll:false]
+## Admin API (manage agents at runtime)
 
-If you have properly set up your dependencies and tests still fail,
-you may want to open up a bug report, as explained next.
+Agents are persisted to `AGENTS_FILE` and can be added/removed without a
+redeploy, using the `ADMIN_API_KEY`:
 
-## Bug reports
+```bash
+# list
+curl -H "Authorization: Bearer $ADMIN_API_KEY" https://openai.bueso.eu/admin/agents
 
-For reporting bugs, [visit our issues tracker][2] and follow the steps
-for reporting a new issue. Please disclose security vulnerabilities
-privately at elixir-security@googlegroups.com.
+# add / update an agent
+curl -X POST -H "Authorization: Bearer $ADMIN_API_KEY" -H "Content-Type: application/json" \
+  -d '{"model":"media-agent","webhook":"https://n8n.bueso.eu/webhook/<id>/chat"}' \
+  https://openai.bueso.eu/admin/agents
 
-## Contributing
-
-We welcome everyone to contribute to Elixir and help us tackle existing issues!
-To do so, there are a few things you need to know about the code. First, Elixir
-code is divided in applications inside the `lib` folder:
-
-* `elixir` - Contains Elixir's kernel and stdlib
-
-* `eex` - Template engine that allows you to embed Elixir
-
-* `ex_unit` - Simple test framework that ships with Elixir
-
-* `iex` - IEx, Elixir's interactive shell
-
-* `logger` - The built-in logger
-
-* `mix` - Elixir's build tool
-
-You can run all tests in the root directory with `make test` and you can
-also run tests for a specific framework `make test_#{NAME}`, for example,
-`make test_ex_unit`. If you just changed something in the Elixir's standard
-library, you can run only that portion through `make test_stdlib`, as
-`test_elixir` also runs tests for the other projects (EEx, ExUnit, etc.).
-
-In case you are changing a single file, you can compile and run tests only
-for that particular file for fast development cycles. For example, if you
-are changing the String module, you can compile it and run its tests as:
-
-```sh
-bin/elixirc lib/elixir/lib/string.ex -o lib/elixir/ebin
-bin/elixir lib/elixir/test/elixir/string_test.exs
+# remove
+curl -X DELETE -H "Authorization: Bearer $ADMIN_API_KEY" \
+  https://openai.bueso.eu/admin/agents/media-agent
 ```
 
-To recompile (including Erlang modules):
+The store is authoritative and persists across restarts; no env config needed.
 
-```sh
-make compile
+## Building & running
+
+```bash
+mix deps.get
+mix compile
+ADAPTER_API_KEY=secret AGENTS='{"scholar-agent":"https://n8n.bueso.eu/webhook/<id>/chat"}' \
+  PORT=8000 mix run --no-halt
 ```
 
-If your contribution fails the build during the bootstrapping of the language,
-you can reproduce it locally by deleting all of Elixir beam files and compiling
-again:
+## Testing
 
-```sh
-make clean_elixir compile
+```bash
+MIX_ENV=test mix test
 ```
 
-Or to rebuild everything from scratch without running tests:
+## Nix
 
-```sh
-make clean compile
+The repo ships a `flake.nix` exporting `overlays.default` and a `packages.default`
+(the packaged BEAM release), so it can be consumed as a flake input from your
+NixOS config just like any other flake — e.g.:
+
+```nix
+inputs.n8n-openai-adapter.url = "git+https://gitea.bueso.eu/<owner>/n8n-openai-adapter";
 ```
-
-More tasks can be found by reading the [Makefile](./Makefile).
-
-After your changes are done, please remember to run the full suite with
-`make test`.
-
-From time to time, your tests may fail in an existing Elixir checkout and
-may require a clean start by running `make clean compile`. You can always
-check [the official build status on Travis-CI](https://travis-ci.org/elixir-lang/elixir).
-
-With tests running and passing, you are ready to contribute to Elixir and
-[send a pull request](https://help.github.com/articles/using-pull-requests/).
-We have saved some excellent pull requests we have received in the past in
-case you are looking for some examples:
-
-* [Implement Enum.member? – Pull Request](https://github.com/elixir-lang/elixir/pull/992)
-* [Add String.valid? – Pull Request](https://github.com/elixir-lang/elixir/pull/1058)
-* [Implement capture_io for ExUnit – Pull Request](https://github.com/elixir-lang/elixir/pull/1059)
-
-We usually keep a list of enhancements and bugs [in the issue tracker][2].
-For proposing new features, please start a discussion in the
-[Elixir Core mailing list][3]. Keep in mind that it is your responsibility
-to argue and explain why a feature is useful and how it will impact the
-codebase and the community. Finally, remember all interactions in our official
-spaces follow our [Code of Conduct][7].
-
-### Reviewing changes
-
-Once a pull request is sent, the Elixir team will review your changes.
-We outline our process below to clarify the roles of everyone involved.
-
-All pull requests must be approved by two committers before being merged into
-the repository. In case any changes are necessary, the team will leave
-appropriate comments requesting changes to the code.
-
-The Elixir team may optionally assign someone to review a pull request.
-In case someone is assigned, they must explicitly approve the code before
-another team member can merge it.
-
-When review is completed, your pull request will be squashed and merged
-into the repository.
-
-## Building documentation
-
-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:
-git clone git://github.com/elixir-lang/ex_doc.git
-cd ex_doc && ../elixir/bin/mix do deps.get, compile
-cd ../elixir && make docs
-```
-
-This will produce documentation sets for `elixir`, `mix`, etc., under
-the `doc` directory. If you are planning to contribute documentation,
-[please check our best practices for writing documentation](https://hexdocs.pm/elixir/writing-documentation.html).
-
-## Development links
-
-  * [Elixir Website][1]
-  * [Elixir Documentation][6]
-  * [Elixir Core Mailing list (development)][3]
-  * [Issues tracker][2]
-  * [Code of Conduct][7]
-  * **[#elixir-lang][4]** on [Freenode][5] IRC
-
-  [1]: 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
-
-## License
-
-"Elixir" and the Elixir logo are copyright (c) 2012 Plataformatec.
-
-Elixir source code is released under Apache 2 License.
-
-Check [NOTICE](NOTICE) and [LICENSE](LICENSE) files for more
-information.

RELEASE.md

@@ -1,35 +0,0 @@
-# Release process
-
-## All releases
-
-This document simply outlines the release process:
-
-1. Ensure you are running on the oldest supported Erlang version
-
-2. Remove all `-dev` extension from versions (see below for all files)
-
-3. Ensure CHANGELOG is updated and add current date
-
-4. If a new `vMAJOR.MINOR`, replace "master" with "vVERSION" in the "Deprecations" page and commit
-
-5. If a new `vMAJOR.MINOR`, create a new branch "vMAJOR.MINOR" and set `CANONICAL=` in Makefile
-
-6. Commit changes above with title "Release vVERSION" and generate new tag
-
-7. Run `make clean test` to ensure all tests pass from scratch and the CI is green
-
-8. Recompile an existing project (for example, Ecto) to ensure manifests can be upgraded
-
-9. Push branch and the new tag
-
-10. Publish new zips with `make zips`, upload `Precompiled.zip` and `Docs.zip` to GitHub Releases
-
-11. Add the release to `elixir.csv` and `_data/elixir-versions.yml` files in `elixir-lang/elixir-lang.github.com`
-
-12. After a new `vMAJOR.MINOR`, move back to master, bump versions, start new CHANGELOG, add `-dev` back and commit "Start vMAJOR.MINOR+1"
-
-## Places where version is mentioned
-
-* VERSION
-* CHANGELOG.md
-* src/elixir.app.src (not lib/elixir/src/elixir.app.src)

VERSION

@@ -1 +0,0 @@
-1.5.0

bin/elixir

@@ -1,127 +0,0 @@
-#!/bin/sh
-if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -pr FILE                    Requires the given files/patterns in parallel (*)
-  -pa PATH                    Prepends the given path to Erlang code path (*)
-  -pz PATH                    Appends the given path to Erlang code path (*)
-
-  --app APP                   Starts the given app and its dependencies (*)
-  --cookie COOKIE             Sets a cookie for this distributed node
-  --detached                  Starts the Erlang VM detached from console
-  --erl SWITCHES              Switches to be passed down to Erlang (*)
-  --help, -h                  Prints this message and exits
-  --hidden                    Makes a hidden node
-  --logger-otp-reports BOOL   Enables or disables OTP reporting
-  --logger-sasl-reports BOOL  Enables or disables SASL reporting
-  --name NAME                 Makes and assigns a name to the distributed node
-  --no-halt                   Does not halt the Erlang VM after execution
-  --sname NAME                Makes and assigns a short name to the distributed node
-  --version, -v               Prints Elixir version and exits
-  --werl                      Uses Erlang's Windows shell GUI (Windows only)
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the Erlang runtime using ELIXIR_ERL_OPTIONS or --erl" >&2
-  exit 1
-fi
-
-readlink_f () {
-  cd "$(dirname "$1")" > /dev/null
-  filename="$(basename "$1")"
-  if [ -h "$filename" ]; then
-    readlink_f "$(readlink "$filename")"
-  else
-    echo "`pwd -P`/$filename"
-  fi
-}
-
-MODE="elixir"
-ERL_EXEC="erl"
-ERL=""
-I=1
-
-while [ $I -le $# ]; do
-  S=1
-  eval "PEEK=\${$I}"
-  case "$PEEK" in
-    +iex)
-        MODE="iex"
-        ;;
-    +elixirc)
-        MODE="elixirc"
-        ;;
-    -v|--compile|--no-halt)
-        ;;
-    -e|-r|-pr|-pa|-pz|--remsh|--app)
-        S=2
-        ;;
-    --detached|--hidden)
-        ERL="$ERL `echo $PEEK | cut -c 2-`"
-        ;;
-    --cookie)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        ERL="$ERL -setcookie "$VAL""
-        ;;
-    --sname|--name)
-        I=$(expr $I + 1)
-        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}"
-        ERL="$ERL "$VAL""
-        ;;
-    --werl)
-        USE_WERL=true
-        ;;
-    *)
-        break
-        ;;
-  esac
-  I=$(expr $I + $S)
-done
-
-SELF=$(readlink_f "$0")
-SCRIPT_PATH=$(dirname "$SELF")
-
-if [ "$OSTYPE" = "cygwin" ]; then SCRIPT_PATH=$(cygpath -m "$SCRIPT_PATH"); fi
-if [ "$MODE" != "iex" ]; then ERL="-noshell -s elixir start_cli $ERL"; fi
-
-# Check for terminal support
-if [ "$OS" != "Windows_NT" ]; then
-  if test -t 1 -a -t 2; then ERL="-elixir ansi_enabled true $ERL"; fi
-fi
-
-if [ "$OS" = "Windows_NT" ] && [ $USE_WERL ]; then
-    ERL_EXEC="werl"
-fi
-
-if [ -z "$ERL_PATH" ]; then
-  if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]; then
-    ERL_PATH="$SCRIPT_PATH"/"$ERL_EXEC"
-  else
-    ERL_PATH="$ERL_EXEC"
-  fi
-fi
-
-exec "$ERL_PATH" -pa "$SCRIPT_PATH"/../lib/*/ebin $ELIXIR_ERL_OPTIONS $ERL -extra "$@"

bin/elixir.bat

@@ -1,114 +0,0 @@
-@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
-goto parseopts
-
-:documentation
-echo Usage: %~nx0 [options] [.exs file] [data]
-echo.
-echo   -e COMMAND                  Evaluates the given command (*)
-echo   -r FILE                     Requires the given files/patterns (*)
-echo   -S SCRIPT                   Finds and executes the given script in PATH
-echo   -pr FILE                    Requires the given files/patterns in parallel (*)
-echo   -pa PATH                    Prepends the given path to Erlang code path (*)
-echo   -pz PATH                    Appends the given path to Erlang code path (*)
-echo.
-echo   --app APP                   Starts the given app and its dependencies (*)
-echo   --cookie COOKIE             Sets a cookie for this distributed node
-echo   --detached                  Starts the Erlang VM detached from console
-echo   --erl SWITCHES              Switches to be passed down to Erlang (*)
-echo   --help, -h                  Prints this message and exits
-echo   --hidden                    Makes a hidden node
-echo   --logger-otp-reports BOOL   Enables or disables OTP reporting
-echo   --logger-sasl-reports BOOL  Enables or disables SASL reporting
-echo   --name NAME                 Makes and assigns a name to the distributed node
-echo   --no-halt                   Does not halt the Erlang VM after execution
-echo   --sname NAME                Makes and assigns a short name to the distributed node
-echo   --version, -v               Prints Elixir version and exits
-echo   --werl                      Uses Erlang's Windows shell GUI
-echo.
-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
-goto end
-
-:parseopts
-
-rem Parameters for Erlang
-set parsErlang=
-
-rem Make sure we keep a copy of all parameters
-set allPars=%*
-
-rem Get the original path name from the batch file
-set originPath=%~dp0
-
-rem Optional parameters before the "-extra" parameter
-set beforeExtra=
-
-rem Flag which determines whether or not to use werl vs erl
-set useWerl=0
-
-rem Designates which mode / Elixir component to run as
-set runMode="elixir"
-
-rem Recursive loop called for each parameter that parses the cmd line parameters
-:startloop
-set par="%1"
-shift
-if "%par%"=="" (
-  rem if no parameters defined
-  goto expand_erl_libs
-)
-if "%par%"=="""" (
-  rem if no parameters defined - special case for parameter that is already quoted
-  goto expand_erl_libs
-)
-rem ******* EXECUTION OPTIONS **********************
-if "%par%"==""--werl"" (set useWerl=1)
-if "%par%"==""+iex"" (set runMode="iex")
-rem ******* ELIXIR PARAMETERS **********************
-rem Note: we don't have to do anything with options that don't take an argument
-if """"=="%par:-e=%"      (shift)
-if """"=="%par:-r=%"      (shift)
-if """"=="%par:-pr=%"     (shift)
-if """"=="%par:-pa=%"     (shift)
-if """"=="%par:-pz=%"     (shift)
-if """"=="%par:--app=%"   (shift)
-if """"=="%par:--remsh=%" (shift)
-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)
-goto:startloop
-
-rem ******* assume all pre-params are parsed ********************
-:expand_erl_libs
-rem ******* expand all ebin paths as Windows does not support the ..\*\ebin wildcard ********************
-setlocal enabledelayedexpansion
-set ext_libs=
-for  /d %%d in ("%originPath%..\lib\*.") do (
-  set ext_libs=!ext_libs! -pa "%%~fd\ebin"
-)
-setlocal disabledelayedexpansion
-
-:run
-if not %runMode% == "iex" (
-  set beforeExtra=-noshell -s elixir start_cli %beforeExtra%
-)
-if %useWerl% equ 1 (
-  start werl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
-) else (
-  erl.exe %ext_libs% %ELIXIR_ERL_OPTIONS% %parsErlang% %beforeExtra% -extra %*
-)
-:end
-endlocal

bin/elixirc

@@ -1,33 +0,0 @@
-#!/bin/sh
-if [ $# -eq 0 ] || [ "$1" = "--help" ] || [ "$1" = "-h" ]; then
-  echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
-
-  -o                        The directory to output compiled files
-
-  --help, -h                Prints this message and exits
-  --ignore-module-conflict  Does not emit warnings if a module was previously defined
-  --no-debug-info           Does not attach debug info to compiled modules
-  --no-docs                 Does not attach documentation to compiled modules
-  --verbose                 Prints compilation status
-  --version, -v             Prints Elixir version and exits
-  --warnings-as-errors      Treats warnings as errors and return non-zero exit code
-
-** 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
-  exit 1
-fi
-
-readlink_f () {
-  cd "$(dirname "$1")" > /dev/null
-  filename="$(basename "$1")"
-  if [ -h "$filename" ]; then
-    readlink_f "$(readlink "$filename")"
-  else
-    echo "`pwd -P`/$filename"
-  fi
-}
-
-SELF=$(readlink_f "$0")
-SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir +elixirc "$@"

bin/elixirc.bat

@@ -1,36 +0,0 @@
-@if defined ELIXIR_CLI_ECHO (@echo on) else (@echo off)
-setlocal
-set argc=0
-for %%A in (%*) do (
-  if /I "%%A"=="--help" goto documentation
-  if /I "%%A"=="-h"     goto documentation
-  if /I "%%A"=="/h"     goto documentation
-  if    "%%A"=="/?"     goto documentation
-  set /A argc+=1
-)
-if %argc%==0 goto documentation
-goto run
-
-:documentation
-echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
-echo.
-echo   -o                        The directory to output compiled files
-echo.
-echo   --help, -h                Prints this message and exits
-echo   --ignore-module-conflict  Does not emit warnings if a module was previously defined
-echo   --no-debug-info           Does not attach debug info to compiled modules
-echo   --no-docs                 Does not attach documentation to compiled modules
-echo   --verbose                 Prints compilation status
-echo   --version, -v             Prints Elixir version and exits
-echo   --warnings-as-errors      Treats warnings as errors and returns non-zero exit code
-echo.
-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
-
-:run
-call "%~dp0\elixir.bat" +elixirc %*
-
-:end
-endlocal

bin/iex

@@ -1,48 +0,0 @@
-#!/bin/sh
-if [ $# -gt 0 ] && ([ "$1" = "--help" ] || [ "$1" = "-h" ]); then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -e COMMAND                  Evaluates the given command (*)
-  -r FILE                     Requires the given files/patterns (*)
-  -S SCRIPT                   Finds and executes the given script in PATH
-  -pr FILE                    Requires the given files/patterns in parallel (*)
-  -pa PATH                    Prepends the given path to Erlang code path (*)
-  -pz PATH                    Appends the given path to Erlang code path (*)
-
-  --app APP                   Starts the given app and its dependencies (*)
-  --cookie COOKIE             Sets a cookie for this distributed node
-  --detached                  Starts the Erlang VM detached from console
-  --erl SWITCHES              Switches to be passed down to Erlang (*)
-  --help, -h                  Prints this message and exits
-  --hidden                    Makes a hidden node
-  --logger-otp-reports BOOL   Enables or disables OTP reporting
-  --logger-sasl-reports BOOL  Enables or disables SASL reporting
-  --name NAME                 Makes and assigns a name to the distributed node
-  --no-halt                   Does not halt the Erlang VM after execution
-  --sname NAME                Makes and assigns a short name to the distributed node
-  --version, -v               Prints IEx version and exits
-  --werl                      Uses Erlang's Windows shell GUI (Windows only)
-
-  --dot-iex PATH              Overrides default .iex.exs file and uses path instead;
-                              path can be empty, then no file will be loaded
-  --remsh NAME                Connects to a node using a remote shell
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the VM using ELIXIR_ERL_OPTIONS or --erl" >&2
-  exit 1
-fi
-
-readlink_f () {
-  cd "$(dirname "$1")" > /dev/null
-  filename="$(basename "$1")"
-  if [ -h "$filename" ]; then
-    readlink_f "$(readlink "$filename")"
-  else
-    echo "`pwd -P`/$filename"
-  fi
-}
-
-SELF=$(readlink_f "$0")
-SCRIPT_PATH=$(dirname "$SELF")
-exec "$SCRIPT_PATH"/elixir --no-halt --erl "-noshell -user Elixir.IEx.CLI" +iex "$@"

bin/iex.bat

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

bin/mix

@@ -1,3 +0,0 @@
-#!/usr/bin/env elixir
-Mix.start
-Mix.CLI.main

bin/mix.bat

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

bin/mix.ps1

@@ -1,23 +0,0 @@
-# Store path to mix.bat as a FileInfo object
-$mixBatPath = (Get-ChildItem (((Get-ChildItem $MyInvocation.MyCommand.Path).Directory.FullName) + '\mix.bat'))
-$newArgs = @()
-
-for ($i = 0; $i -lt $args.length; $i++)
-{
-  if ($args[$i] -is [array])
-  {
-    # Commas created the array so we need to reintroduce those commas
-    for ($j = 0; $j -lt $args[$i].length - 1; $j++)
-    {
-      $newArgs += ($args[$i][$j] + ',')
-    }
-    $newArgs += $args[$i][-1]
-  }
-  else
-  {
-    $newArgs += $args[$i]
-  }
-}
-
-# Corrected arguments are ready to pass to batch file
-& $mixBatPath $newArgs

config/config.exs

@@ -0,0 +1,7 @@
+import Config
+
+import_config "#{config_env()}.exs"
+
+if config_env() == :test do
+  config :logger, level: :warning
+end

config/dev.exs

@@ -0,0 +1,3 @@
+import Config
+
+# Dev: no special config — all runtime settings come from env vars.

config/prod.exs

@@ -0,0 +1,5 @@
+import Config
+
+# Production: no hardcoded values here. All runtime config (PORT, AGENTS,
+# ADAPTER_API_KEY, CHAT_WEBHOOK_BASIC) comes from the systemd EnvironmentFile
+# in the NixOS service module.

config/test.exs

@@ -0,0 +1,7 @@
+import Config
+
+# Test environment: the app starts with an empty agent store (no AGENTS env
+# seeding — agents are managed via the admin API). ADAPTER_API_KEY /
+# ADMIN_API_KEY are set in test/test_helper.exs. AGENTS_FILE must be set HERE
+# (config loads before the app boots) to a writable tmp path.
+System.put_env("AGENTS_FILE", Path.join(System.tmp_dir!(), "n8n-openai-test-agents.json"))

flake.lock

@@ -0,0 +1,27 @@
+{
+  "nodes": {
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1788881743,
+        "narHash": "sha256-2V9GZGvPfrNzxFozhI9dcqV+c3QdA8YZrvAAzqEB+dI=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "d6524aaca2ff07876657ae2b323f24be4874944b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "nixpkgs": "nixpkgs"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,48 @@
+{
+  description = "OpenAI-compatible adapter exposing n8n chat agents behind /v1/chat/completions";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+  };
+
+  outputs =
+    { self, nixpkgs, ... }:
+    let
+      supportedSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+      ];
+      forAllSystems = nixpkgs.lib.genAttrs supportedSystems;
+    in
+    {
+      packages = forAllSystems (
+        system:
+        let
+          pkgs = import nixpkgs { inherit system; };
+          beamPackages = pkgs.beamPackages;
+        in
+        {
+          default = beamPackages.mixRelease {
+            pname = "n8n-openai-adapter";
+            version = "0.1.0";
+            src = self;
+            mixFodDeps = beamPackages.fetchMixDeps {
+              pname = "n8n-openai-adapter";
+              version = "0.1.0";
+              src = self;
+              hash = "sha256-sdAhpZUeF33V9xjEa/z/aTmCllfetMjO/1XyfJfUNao=";
+            };
+          };
+        }
+      );
+
+      overlays.default = final: prev: {
+        n8n-openai-adapter = self.packages.${final.stdenv.system}.default;
+      };
+
+      # Proper NixOS module: consume with
+      #   imports = [ inputs.n8n-openai-adapter.nixosModules.default ];
+      #   services.n8n-openai-adapter = { enable = true; domain = "..."; port = 8134; };
+      nixosModules.default = import ./nixos-module.nix;
+    };
+}

lib/eex/lib/eex.ex

@@ -1,226 +0,0 @@
-defmodule EEx.SyntaxError do
-  defexception [:message, :file, :line]
-
-  def message(exception) do
-    "#{exception.file}:#{exception.line}: #{exception.message}"
-  end
-end
-
-defmodule EEx do
-  @moduledoc ~S"""
-  EEx stands for Embedded Elixir. It allows you to embed
-  Elixir code inside a string in a robust way.
-
-      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      "foo baz"
-
-  ## API
-
-  This module provides 3 main APIs for you to use:
-
-    1. Evaluate a string (`eval_string`) or a file (`eval_file`)
-       directly. This is the simplest API to use but also the
-       slowest, since the code is evaluated and not compiled before.
-
-    2. Define a function from a string (`function_from_string`)
-       or a file (`function_from_file`). This allows you to embed
-       the template as a function inside a module which will then
-       be compiled. This is the preferred API if you have access
-       to the template at compilation time.
-
-    3. Compile a string (`compile_string`) or a file (`compile_file`)
-       into Elixir syntax tree. This is the API used by both functions
-       above and is available to you if you want to provide your own
-       ways of handling the compiled template.
-
-  ## Options
-
-  All functions in this module accept 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
-
-  EEx has the concept of engines which allows you to modify or
-  transform the code extracted from the given string or file.
-
-  By default, `EEx` uses the `EEx.SmartEngine` that provides some
-  conveniences on top of the simple `EEx.Engine`.
-
-  ### Tags
-
-  `EEx.SmartEngine` supports the following tags:
-
-      <% Elixir expression - inline with output %>
-      <%= Elixir expression - replace with result %>
-      <%% EEx quotation - returns the contents inside %>
-      <%# Comments - they are discarded from source %>
-
-  All expressions that output something to the template
-  **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
-  also require `=` in order to have their result printed:
-
-      <%= if true do %>
-        It is obviously true
-      <% else %>
-        This will never appear
-      <% end %>
-
-  Notice that different engines may have different rules
-  for each tag. Other tags may be added in future versions.
-
-  ### Macros
-
-  `EEx.SmartEngine` also adds some macros to your template.
-  An example is the `@` macro which allows easy data access
-  in a template:
-
-      iex> EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
-      "1"
-
-  In other words, `<%= @foo %>` translates to:
-
-      <%= {:ok, v} = Access.fetch(assigns, :foo); v %>
-
-  The `assigns` extension is useful when the number of variables
-  required by the template is not specified at compilation time.
-  """
-
-  @doc """
-  Generates a function definition from the string.
-
-  The kind (`:def` or `:defp`) must be given, the
-  function name, its arguments and the compilation options.
-
-  ## Examples
-
-      iex> defmodule Sample do
-      ...>   require EEx
-      ...>   EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
-      ...> end
-      iex> Sample.sample(1, 2)
-      "3"
-
-  """
-  defmacro function_from_string(kind, name, source, args \\ [], options \\ []) do
-    quote bind_quoted: binding() do
-      info = Keyword.merge [file: __ENV__.file, line: __ENV__.line], options
-      args = Enum.map args, fn arg -> {arg, [line: info[:line]], nil} end
-      compiled = EEx.compile_string(source, info)
-
-      case kind do
-        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-      end
-    end
-  end
-
-  @doc """
-  Generates a function definition from the file contents.
-
-  The kind (`:def` or `:defp`) must be given, the
-  function name, its arguments and the compilation options.
-
-  This function is useful in case you have templates but
-  you want to precompile inside a module for speed.
-
-  ## Examples
-
-      # sample.eex
-      <%= a + b %>
-
-      # sample.ex
-      defmodule Sample do
-        require EEx
-        EEx.function_from_file :def, :sample, "sample.eex", [:a, :b]
-      end
-
-      # iex
-      Sample.sample(1, 2) #=> "3"
-
-  """
-  defmacro function_from_file(kind, name, file, args \\ [], options \\ []) do
-    quote bind_quoted: binding() do
-      info = Keyword.merge options, [file: file, line: 1]
-      args = Enum.map args, fn arg -> {arg, [line: 1], nil} end
-      compiled = EEx.compile_file(file, info)
-
-      @external_resource file
-      @file file
-      case kind do
-        :def  -> def(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-        :defp -> defp(unquote(name)(unquote_splicing(args)), do: unquote(compiled))
-      end
-    end
-  end
-
-  @doc """
-  Gets a string `source` and generate a quoted expression
-  that can be evaluated by Elixir or compiled to a function.
-  """
-  @spec compile_string(String.t, keyword) :: Macro.t | no_return
-  def compile_string(source, options \\ []) when is_binary(source) and is_list(options) do
-    EEx.Compiler.compile(source, options)
-  end
-
-  @doc """
-  Gets a `filename` and generate a quoted expression
-  that can be evaluated by Elixir or compiled to a function.
-  """
-  @spec compile_file(String.t, keyword) :: Macro.t | no_return
-  def compile_file(filename, options \\ []) when is_binary(filename) and is_list(options) do
-    options = Keyword.merge options, [file: filename, line: 1]
-    compile_string(File.read!(filename), options)
-  end
-
-  @doc """
-  Gets a string `source` and evaluate the values using the `bindings`.
-
-  ## Examples
-
-      iex> EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      "foo baz"
-
-  """
-  @spec eval_string(String.t, keyword, keyword) :: any
-  def eval_string(source, bindings \\ [], options \\ [])
-      when is_binary(source) and is_list(bindings) and is_list(options) do
-    compiled = compile_string(source, options)
-    do_eval(compiled, bindings, options)
-  end
-
-  @doc """
-  Gets a `filename` and evaluate the values using the `bindings`.
-
-  ## Examples
-
-      # sample.eex
-      foo <%= bar %>
-
-      # iex
-      EEx.eval_file "sample.eex", [bar: "baz"] #=> "foo baz"
-
-  """
-  @spec eval_file(String.t, keyword, keyword) :: any
-  def eval_file(filename, bindings \\ [], options \\ [])
-      when is_binary(filename) and is_list(bindings) and is_list(options) do
-    options  = Keyword.put options, :file, filename
-    compiled = compile_file(filename, options)
-    do_eval(compiled, bindings, options)
-  end
-
-  ### Helpers
-
-  defp do_eval(compiled, bindings, options) do
-    {result, _} = Code.eval_quoted(compiled, bindings, options)
-    result
-  end
-end

lib/eex/lib/eex/compiler.ex

@@ -1,147 +0,0 @@
-defmodule EEx.Compiler do
-  @moduledoc false
-
-  # When changing this setting, don't forget to update the docs for EEx
-  @default_engine EEx.SmartEngine
-
-  @doc """
-  This is the compilation entry point. It glues the tokenizer
-  and the engine together by handling the tokens and invoking
-  the engine every time a full expression or text is received.
-  """
-  @spec compile(String.t, keyword) :: Macro.t | no_return
-  def compile(source, opts) when is_binary(source) and is_list(opts) do
-    file = opts[:file] || "nofile"
-    line = opts[:line] || 1
-    trim = opts[:trim] || false
-    case EEx.Tokenizer.tokenize(source, line, trim: trim) do
-      {:ok, tokens} ->
-        state = %{engine: opts[:engine] || @default_engine, init: nil,
-                  file: file, line: line, quoted: [], start_line: nil}
-        init = state.engine.init(opts)
-        generate_buffer(tokens, init, [], %{state | init: init})
-      {:error, line, message} ->
-        raise EEx.SyntaxError, line: line, file: file, message: message
-    end
-  end
-
-  # Generates the buffers by handling each expression from the tokenizer.
-  # It returns Macro.t/0 or it raises.
-
-  defp generate_buffer([{:text, chars} | rest], buffer, scope, state) do
-    buffer = state.engine.handle_text(buffer, IO.chardata_to_string(chars))
-    generate_buffer(rest, buffer, scope, state)
-  end
-
-  defp generate_buffer([{:expr, line, mark, chars} | rest], buffer, scope, state) do
-    expr = Code.string_to_quoted!(chars, [line: line, file: state.file])
-    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), expr)
-    generate_buffer(rest, buffer, scope, state)
-  end
-
-  defp generate_buffer([{:start_expr, start_line, mark, chars} | rest], buffer, scope, state) do
-    {contents, line, rest} = look_ahead_text(rest, start_line, chars)
-    {contents, rest} =
-      generate_buffer(rest, state.init, [contents | scope],
-                      %{state | quoted: [], line: line, start_line: start_line})
-    buffer = state.engine.handle_expr(buffer, IO.chardata_to_string(mark), contents)
-    generate_buffer(rest, buffer, scope, state)
-  end
-
-  defp generate_buffer([{:middle_expr, line, '', chars} | rest], buffer, [current | scope], state) do
-    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    generate_buffer(rest, state.init, [wrapped | scope], %{state | line: line})
-  end
-
-  defp generate_buffer([{:middle_expr, line, modifier, chars} | t], buffer, scope, state) do
-    message = "unexpected beginning of EEx tag \"<%#{modifier}\" on \"<%#{modifier}#{chars}%>\", " <>
-              "please remove \"#{modifier}\" accordingly"
-    :elixir_errors.warn line, state.file, message
-    generate_buffer([{:middle_expr, line, '', chars} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
-  end
-
-  defp generate_buffer([{:end_expr, line, '', chars} | rest], buffer, [current | _], state) do
-    {wrapped, state} = wrap_expr(current, line, buffer, chars, state)
-    tuples = Code.string_to_quoted!(wrapped, [line: state.start_line, file: state.file])
-    buffer = insert_quoted(tuples, state.quoted)
-    {buffer, rest}
-  end
-
-  defp generate_buffer([{:end_expr, line, modifier, chars} | t], buffer, [_ | _] = scope, state) do
-    message = "unexpected beginning of EEx tag \"<%#{modifier}\" on end of expression \"<%#{modifier}#{chars}%>\", " <>
-              "please remove \"#{modifier}\" accordingly"
-    :elixir_errors.warn line, state.file, message
-    generate_buffer([{:end_expr, line, '', chars} | t], buffer, scope, state)
-    # TODO: Make this an error on Elixir v2.0 since it accidentally worked previously.
-    # raise EEx.SyntaxError, message: message, file: state.file, line: line
-  end
-
-  defp generate_buffer([{:end_expr, line, _, chars} | _], _buffer, [], state) do
-    raise EEx.SyntaxError, message: "unexpected end of expression <%#{chars}%>",
-                           file: state.file, line: line
-  end
-
-  defp generate_buffer([], buffer, [], state) do
-    state.engine.handle_body(buffer)
-  end
-
-  defp generate_buffer([], _buffer, _scope, state) do
-    raise EEx.SyntaxError, message: "unexpected end of string, expected a closing '<% end %>'",
-                           file: state.file, line: state.line
-  end
-
-  # Creates a placeholder and wrap it inside the expression block
-
-  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) ++ ');'
-    {current ++ placeholder ++ new_lines ++ chars,
-     %{state | quoted: [{key, buffer} | state.quoted]}}
-  end
-
-  # Look text ahead on expressions
-
-  defp look_ahead_text([{:text, text}, {:middle_expr, line, _, chars} | rest] = tokens, start, contents) do
-    if only_spaces?(text) do
-      {contents ++ text ++ chars, line, rest}
-    else
-      {contents, start, tokens}
-    end
-  end
-  defp look_ahead_text([{:middle_expr, line, _, chars} | rest], _start, contents) do
-    {contents ++ chars, line, rest}
-  end
-  defp look_ahead_text(tokens, start, contents) do
-    {contents, start, tokens}
-  end
-
-  defp only_spaces?(chars) do
-    Enum.all?(chars, &(&1 in [?\s, ?\t, ?\r, ?\n]))
-  end
-
-  # Changes placeholder to real expression
-
-  defp insert_quoted({:__EEX__, _, [key]}, quoted) do
-    {^key, value} = List.keyfind quoted, key, 0
-    value
-  end
-
-  defp insert_quoted({left, line, right}, quoted) do
-    {insert_quoted(left, quoted), line, insert_quoted(right, quoted)}
-  end
-
-  defp insert_quoted({left, right}, quoted) do
-    {insert_quoted(left, quoted), insert_quoted(right, quoted)}
-  end
-
-  defp insert_quoted(list, quoted) when is_list(list) do
-    Enum.map list, &insert_quoted(&1, quoted)
-  end
-
-  defp insert_quoted(other, _quoted) do
-    other
-  end
-end

lib/eex/lib/eex/engine.ex

@@ -1,143 +0,0 @@
-defmodule EEx.Engine do
-  @moduledoc ~S"""
-  Basic EEx engine that ships with Elixir.
-
-  An engine needs to implement four 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.
-
-    * `handle_text(buffer, text)` - it receives the buffer,
-      the text and must return a new quoted expression.
-
-    * `handle_expr(buffer, marker, expr)` - it receives the buffer,
-      the marker, the expr and must return a new quoted expression.
-
-      The marker is what follows exactly after `<%`. For example,
-      `<% foo %>` has an empty marker, but `<%= foo %>` has `"="`
-      as marker. The allowed markers so far are: `""` and `"="`.
-
-      Read `handle_expr/3` below for more information about the markers
-      implemented by default by this engine.
-
-  `EEx.Engine` can be used directly if one desires to use the
-  default implementations for the functions above.
-  """
-
-  @callback init(opts :: keyword) :: Macro.t
-  @callback handle_body(quoted :: Macro.t) :: Macro.t
-  @callback handle_text(buffer :: Macro.t, text :: String.t) :: Macro.t
-  @callback handle_expr(buffer :: Macro.t, marker :: String.t, expr :: Macro.t) :: Macro.t
-
-  @doc false
-  defmacro __using__(_) do
-    quote do
-      @behaviour EEx.Engine
-
-      def init(opts) do
-        EEx.Engine.init(opts)
-      end
-
-      def handle_body(quoted) do
-        EEx.Engine.handle_body(quoted)
-      end
-
-      def handle_text(buffer, text) do
-        EEx.Engine.handle_text(buffer, text)
-      end
-
-      def handle_expr(buffer, marker, expr) do
-        EEx.Engine.handle_expr(buffer, marker, expr)
-      end
-
-      defoverridable EEx.Engine
-    end
-  end
-
-  @doc """
-  Handles assigns in quoted expressions.
-
-  A warning will be printed on missing assigns.
-  Future versions will raise.
-
-  This can be added to any custom engine by invoking
-  `handle_assign/1` with `Macro.prewalk/2`:
-
-      def handle_expr(buffer, token, expr) do
-        expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-        EEx.Engine.handle_expr(buffer, token, expr)
-      end
-
-  """
-  @spec handle_assign(Macro.t) :: Macro.t
-  def handle_assign({:@, meta, [{name, _, atom}]}) when is_atom(name) and is_atom(atom) do
-    line = meta[:line] || 0
-    quote line: line, do: EEx.Engine.fetch_assign!(var!(assigns), unquote(name))
-  end
-  def handle_assign(arg) do
-    arg
-  end
-
-  @doc false
-  # TODO: Raise on 2.0
-  @spec fetch_assign!(Access.t, Access.key) :: term | nil
-  def fetch_assign!(assigns, key) do
-    case Access.fetch(assigns, key) do
-      {:ok, val} ->
-        val
-      :error ->
-        keys = Enum.map(assigns, &elem(&1, 0))
-        IO.warn "assign @#{key} not available in EEx template. " <>
-                "Please ensure all assigns are given as options. " <>
-                "Available assigns: #{inspect keys}"
-        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.
-  """
-  def handle_body(quoted) do
-    quoted
-  end
-
-  @doc """
-  The default implementation simply concatenates text to the buffer.
-  """
-  def handle_text(buffer, text) do
-    quote do: unquote(buffer) <> unquote(text)
-  end
-
-  @doc """
-  Implements expressions according to the markers.
-
-      <% Elixir expression - inline with output %>
-      <%= Elixir expression - replace with result %>
-
-  All other markers are not implemented by this engine.
-  """
-  def handle_expr(buffer, "=", expr) do
-    quote do
-      tmp1 = unquote(buffer)
-      tmp1 <> String.Chars.to_string(unquote(expr))
-    end
-  end
-
-  def handle_expr(buffer, "", expr) do
-    quote do
-      tmp2 = unquote(buffer)
-      unquote(expr)
-      tmp2
-    end
-  end
-end

lib/eex/lib/eex/smart_engine.ex

@@ -1,41 +0,0 @@
-defmodule EEx.SmartEngine do
-  @moduledoc """
-  The default engine used by EEx.
-
-  It includes assigns (like `@foo`) and possibly other
-  conveniences in the future.
-
-  ## Examples
-
-      iex> EEx.eval_string("<%= @foo %>", assigns: [foo: 1])
-      "1"
-
-  In the example above, we can access the value `foo` under
-  the binding `assigns` using `@foo`. This is useful because
-  a template, after being compiled, can receive different
-  assigns and would not require recompilation for each
-  variable set.
-
-  Assigns can also be used when compiled to a function:
-
-      # sample.eex
-      <%= @a + @b %>
-
-      # sample.ex
-      defmodule Sample do
-        require EEx
-        EEx.function_from_file :def, :sample, "sample.eex", [:assigns]
-      end
-
-      # iex
-      Sample.sample(a: 1, b: 2) #=> "3"
-
-  """
-
-  use EEx.Engine
-
-  def handle_expr(buffer, mark, expr) do
-    expr = Macro.prewalk(expr, &EEx.Engine.handle_assign/1)
-    super(buffer, mark, expr)
-  end
-end

lib/eex/lib/eex/tokenizer.ex

@@ -1,222 +0,0 @@
-defmodule EEx.Tokenizer do
-  @moduledoc false
-
-  @type content :: IO.chardata
-  @type line :: non_neg_integer
-  @type token :: {:text, content} |
-                 {:expr | :start_expr | :middle_expr | :end_expr, line, '=' | '', content}
-
-  @doc """
-  Tokenizes the given charlist or binary.
-
-  It returns {:ok, list} with the following tokens:
-
-    * `{:text, content}`
-    * `{:expr, line, marker, content}`
-    * `{:start_expr, line, marker, content}`
-    * `{:middle_expr, line, marker, content}`
-    * `{:end_expr, line, marker, content}`
-
-  Or `{:error, line, error}` in case of errors.
-  """
-  @spec tokenize(binary | charlist, line, keyword) :: {:ok, [token]} | {:error, line, String.t}
-  def tokenize(bin, line, opts \\ [])
-
-  def tokenize(bin, line, opts)
-      when is_binary(bin) and is_integer(line) and line >= 0 and is_list(opts) do
-    tokenize(String.to_charlist(bin), line, opts)
-  end
-
-  def tokenize(list, line, opts)
-      when is_list(list) and is_integer(line) and line >= 0 and is_list(opts) do
-    tokenize(list, line, opts, [], [])
-  end
-
-  defp tokenize('<%%' ++ t, line, opts, buffer, acc) do
-   tokenize t, line, opts, [?%, ?< | buffer], acc
-  end
-
-  defp tokenize('<%#' ++ t, line, opts, buffer, acc) do
-    case expr(t, line, []) do
-      {:error, _, _} = error -> error
-      {:ok, _, new_line, rest} ->
-        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        tokenize rest, new_line, opts, buffer, acc
-    end
-  end
-
-  defp tokenize('<%' ++ t, line, opts, buffer, acc) do
-    {marker, t} = retrieve_marker(t)
-
-    case expr(t, line, []) do
-      {:error, _, _} = error -> error
-      {:ok, expr, new_line, rest} ->
-        token = token_name(expr)
-        {rest, new_line, buffer} = trim_if_needed(rest, new_line, opts, buffer, acc)
-        acc   = tokenize_text(buffer, acc)
-        final = {token, line, marker, Enum.reverse(expr)}
-        tokenize rest, new_line, opts, [], [final | acc]
-    end
-  end
-
-  defp tokenize('\n' ++ t, line, opts, buffer, acc) do
-    tokenize t, line + 1, opts, [?\n | buffer], acc
-  end
-
-  defp tokenize([h | t], line, opts, buffer, acc) do
-    tokenize t, line, opts, [h | buffer], acc
-  end
-
-  defp tokenize([], _line, _opts, buffer, acc) do
-    {:ok, Enum.reverse(tokenize_text(buffer, acc))}
-  end
-
-  # Retrieve marker for <%
-
-  defp retrieve_marker('=' ++ t) do
-    {'=', t}
-  end
-
-  defp retrieve_marker(t) do
-    {'', t}
-  end
-
-  # Tokenize an expression until we find %>
-
-  defp expr([?%, ?> | t], line, buffer) do
-    {:ok, buffer, line, t}
-  end
-
-  defp expr('\n' ++ t, line, buffer) do
-    expr t, line + 1, [?\n | buffer]
-  end
-
-  defp expr([h | t], line, buffer) do
-    expr t, line, [h | buffer]
-  end
-
-  defp expr([], line, _buffer) do
-    {:error, line, "missing token '%>'"}
-  end
-
-  # Receive an expression content and check
-  # if it is a start, middle or an end token.
-  #
-  # Start tokens finish with "do" and "fn ->"
-  # 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
-    token_name(t)
-  end
-
-  defp token_name('od' ++ [h | _]) when h in [?\s, ?\t, ?)] do
-    :start_expr
-  end
-
-  defp token_name('>-' ++ rest) do
-    rest = Enum.reverse(rest)
-
-    # Tokenize the remaining passing check_terminators as
-    # false, which relax the tokenizer to not error on
-    # unmatched pairs. Then, we check if there is a "fn"
-    # token and, if so, it is not followed by an "end"
-    # token. If this is the case, we are on a start expr.
-    case :elixir_tokenizer.tokenize(rest, 1, file: "eex", check_terminators: false) do
-      {:ok, _line, _column, tokens} ->
-        tokens   = Enum.reverse(tokens)
-        fn_index = fn_index(tokens)
-
-        if fn_index && end_index(tokens) > fn_index do
-          :start_expr
-        else
-          :middle_expr
-        end
-      _error ->
-        :middle_expr
-    end
-  end
-
-  defp token_name('esle' ++ t),   do: check_spaces(t, :middle_expr)
-  defp token_name('retfa' ++ t),  do: check_spaces(t, :middle_expr)
-  defp token_name('hctac' ++ t),  do: check_spaces(t, :middle_expr)
-  defp token_name('eucser' ++ t), do: check_spaces(t, :middle_expr)
-  defp token_name('dne' ++ t),    do: check_spaces(t, :end_expr)
-
-  defp token_name(_) do
-    :expr
-  end
-
-  defp fn_index(tokens) do
-    Enum.find_index tokens, fn
-      {:fn_paren, _} -> true
-      {:fn, _}       -> true
-      _              -> false
-    end
-  end
-
-  defp end_index(tokens) do
-    Enum.find_index(tokens, &match?({:end, _}, &1)) || :infinity
-  end
-
-  defp check_spaces(string, token) do
-    if Enum.all?(string, &(&1 in [?\s, ?\t])) do
-      token
-    else
-      :expr
-    end
-  end
-
-  # Tokenize the buffered text by appending
-  # it to the given accumulator.
-
-  defp tokenize_text([], acc) do
-    acc
-  end
-
-  defp tokenize_text(buffer, acc) do
-    [{:text, Enum.reverse(buffer)} | acc]
-  end
-
-  # If trim mode is enabled and the token is on a line with
-  # only itself and whitespace, trim the whitespace around it,
-  # including the line break following it if there is one.
-  defp trim_if_needed(rest, line, opts, buffer, acc) do
-    original = {rest, line, buffer}
-    if opts[:trim] do
-      case {trim_left(buffer, acc), trim_right(rest, line)} do
-        {{true, new_buffer}, {true, new_rest, new_line}} ->
-          {new_rest, new_line, new_buffer}
-        _ ->
-          original
-      end
-    else
-      original
-    end
-  end
-
-  defp trim_left(buffer, acc) do
-    case {trim_whitespace(buffer), acc} do
-      {[?\n | _] = trimmed_buffer, _} -> {true, trimmed_buffer}
-      {[], []} -> {true, []}
-      _ -> {false, buffer}
-    end
-  end
-
-  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}
-      [] -> {true, [], line}
-      _ -> {false, rest, line}
-    end
-  end
-
-  defp trim_whitespace([h | t]) when h == ?\s or h == ?\t do
-    trim_whitespace(t)
-  end
-
-  defp trim_whitespace(list) do
-    list
-  end
-end

lib/eex/mix.exs

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

lib/eex/test/eex/smart_engine_test.exs

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

lib/eex/test/eex/tokenizer_test.exs

@@ -1,163 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule EEx.TokenizerTest do
-  use ExUnit.Case, async: true
-  require EEx.Tokenizer, as: T
-
-  test "simple chars lists" do
-    assert T.tokenize('foo', 1) == {:ok, [{:text, 'foo'}]}
-  end
-
-  test "simple strings" do
-    assert T.tokenize("foo", 1) == {:ok, [{:text, 'foo'}]}
-  end
-
-  test "strings with embedded code" do
-    assert T.tokenize('foo <% bar %>', 1) ==
-           {:ok, [{:text, 'foo '}, {:expr, 1, '', ' bar '}]}
-  end
-
-  test "strings with embedded equals code" do
-    assert T.tokenize('foo <%= bar %>', 1) ==
-           {:ok, [{:text, 'foo '}, {:expr, 1, '=', ' bar '}]}
-  end
-
-  test "strings with more than one line" do
-    assert T.tokenize('foo\n<%= bar %>', 1) ==
-           {:ok, [{:text, 'foo\n'}, {:expr, 2, '=', ' bar '}]}
-  end
-
-  test "strings with more than one line and expression with more than one line" do
-    string = '''
-foo <%= bar
-
-baz %>
-<% foo %>
-'''
-
-    assert T.tokenize(string, 1) == {:ok, [
-      {:text, 'foo '},
-      {:expr, 1, '=', ' bar\n\nbaz '},
-      {:text, '\n'},
-      {:expr, 4, '', ' foo '},
-      {:text, '\n'}
-    ]}
-  end
-
-  test "quotation" do
-    assert T.tokenize('foo <%% true %>', 1) == {:ok, [
-      {:text, 'foo <% true %>'}
-    ]}
-  end
-
-  test "quotation with do/end" do
-    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == {:ok, [
-      {:text, 'foo <% true do %>bar<% end %>'}
-    ]}
-  end
-
-  test "quotation with interpolation" do
-    assert T.tokenize('a <%% b <%= c %> <%= d %> e %> f', 1) == {:ok, [
-      {:text, 'a <% b '},
-      {:expr, 1, '=', ' c '},
-      {:text, ' '},
-      {:expr, 1, '=', ' d '},
-      {:text, ' e %> f'}
-    ]}
-
-    assert T.tokenize('<%%% a <%%= b %> c %>', 1) == {:ok, [
-      {:text, '<%% a <%= b %> c %>'}
-    ]}
-  end
-
-  test "comments" do
-    assert T.tokenize('foo <%# true %>', 1) == {:ok, [
-      {:text, 'foo '}
-    ]}
-  end
-
-  test "comments with do/end" do
-    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == {:ok, [
-      {:text, 'foo bar'}
-    ]}
-  end
-
-  test "strings with embedded do end" do
-    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == {:ok, [
-      {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do '},
-      {:text, 'bar'},
-      {:end_expr, 1, '', ' end '}
-    ]}
-  end
-
-  test "strings with embedded -> end" do
-    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == {:ok, [
-      {:text, 'foo '},
-      {:start_expr, 1, '', ' cond do '},
-      {:middle_expr, 1, '', ' false -> '},
-      {:text, 'bar'},
-      {:middle_expr, 1, '', ' true -> '},
-      {:text, 'baz'},
-      {:end_expr, 1, '', ' end '}
-    ]}
-  end
-
-  test "strings with embedded keywords blocks" do
-    assert T.tokenize('foo <% if true do %>bar<% else %>baz<% end %>', 1) == {:ok, [
-      {:text, 'foo '},
-      {:start_expr, 1, '', ' if true do '},
-      {:text, 'bar'},
-      {:middle_expr, 1, '', ' else '},
-      {:text, 'baz'},
-      {:end_expr, 1, '', ' end '}
-    ]}
-  end
-
-  test "trim mode" do
-    template = '\t<%= if true do %> \n TRUE \n  <% else %>\n FALSE \n  <% end %>  '
-    assert T.tokenize(template, 1, trim: true) == {:ok, [
-      {:start_expr, 1, '=', ' if true do '},
-      {:text, ' TRUE \n'},
-      {:middle_expr, 3, '', ' else '},
-      {:text, ' FALSE \n'},
-      {:end_expr, 5, '', ' end '}
-    ]}
-  end
-
-  test "trim mode with comment" do
-    assert T.tokenize('  <%# comment %>  \n123', 1, trim: true) == {:ok, [
-      {:text, '123'}
-    ]}
-  end
-
-  test "trim mode with CRLF" do
-    assert T.tokenize('0\r\n  <%= 12 %>  \r\n34', 1, trim: true) == {:ok, [
-      {:text, '0\r\n'},
-      {:expr, 2, '=', ' 12 '},
-      {:text, '34'}
-    ]}
-  end
-
-  test "trim mode set to false" do
-    assert T.tokenize(' <%= 12 %> \n', 1, trim: false) == {:ok, [
-      {:text, ' '},
-      {:expr, 1, '=', ' 12 '},
-      {:text, ' \n'}
-    ]}
-  end
-
-  test "trim mode no false positives" do
-    assert_not_trimmed = fn x -> assert T.tokenize(x, 1, trim: true) == T.tokenize(x, 1) end
-
-    assert_not_trimmed.('foo <%= "bar" %>  ')
-    assert_not_trimmed.('\n  <%= "foo" %>bar')
-    assert_not_trimmed.('  <%% hello %>  ')
-    assert_not_trimmed.('  <%= 01 %><%= 23 %>\n')
-  end
-
-  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

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

lib/eex/test/fixtures/eex_template.eex

@@ -1 +0,0 @@
-foo <%= if true do %>bar.<% end %>

lib/eex/test/fixtures/eex_template_with_bindings.eex

@@ -1 +0,0 @@
-foo <%= bar %>

lib/eex/test/test_helper.exs

@@ -1 +0,0 @@
-ExUnit.start [trace: "--trace" in System.argv]

lib/elixir/lib/access.ex

@@ -1,703 +0,0 @@
-defmodule Access do
-  @moduledoc """
-  Key-based access to data structures using the `data[key]` syntax.
-
-  Elixir provides two syntaxes for accessing values. `user[:name]`
-  is used by dynamic structures, like maps and keywords, while
-  `user.name` is used by structs. The main difference is that
-  `user[:name]` won't raise if the key `:name` is missing but
-  `user.name` will raise if there is no `:name` key.
-
-  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
-
-  Out of the box, `Access` works with `Keyword` and `Map`:
-
-      iex> keywords = [a: 1, b: 2]
-      iex> keywords[:a]
-      1
-
-      iex> map = %{a: 1, b: 2}
-      iex> map[:a]
-      1
-
-      iex> star_ratings = %{1.0 => "★", 1.5 => "★☆", 2.0 => "★★"}
-      iex> star_ratings[1.5]
-      "★☆"
-
-  Note that the dynamic lookup syntax (`term[key]`) roughly translates to
-  `Access.get(term, key, nil)`.
-
-  `Access` can be combined with `Kernel.put_in/3` to put a value
-  in a given key:
-
-      iex> map = %{a: 1, b: 2}
-      iex> put_in map[:a], 3
-      %{a: 3, b: 2}
-
-  This syntax is very convenient as it can be nested arbitrarily:
-
-      iex> users = %{"john" => %{age: 27}, "meg" => %{age: 23}}
-      iex> put_in users["john"][:age], 28
-      %{"john" => %{age: 28}, "meg" => %{age: 23}}
-
-  Furthermore, `Access` transparently ignores `nil` values:
-
-      iex> keywords = [a: 1, b: 2]
-      iex> keywords[:c][:unknown]
-      nil
-
-  Since `Access` is a behaviour, it can be implemented for key-value
-  data structures. The implementation should be added to the
-  module that defines the struct being accessed. `Access` requires the
-  key comparison to be implemented using the `===` operator.
-
-  ## Static lookups
-
-  The `Access` syntax (`data[key]`) cannot be used to access fields in
-  structs, since structs do not implement the `Access` behaviour by
-  default. It is also a design decision: the dynamic access lookup
-  is meant to be used for dynamic key-value structures, like maps
-  and keywords, and not by static ones like structs (where fields are
-  known and not dynamic).
-
-  Therefore Elixir provides a static lookup for struct fields and for atom
-  fields in maps. Imagine a struct named `User` with a `:name` field.
-  The following would raise:
-
-      user = %User{name: "John"}
-      user[:name]
-      # ** (UndefinedFunctionError) undefined function User.fetch/2 (User does not implement the Access behaviour)
-
-  Structs instead use the `user.name` syntax to access fields:
-
-      user.name
-      #=> "John"
-
-  The same `user.name` syntax can also be used by `Kernel.put_in/2`
-  for updating structs fields:
-
-      put_in user.name, "Mary"
-      #=> %User{name: "Mary"}
-
-  Differently from `user[:name]`, `user.name` is not extensible via
-  a behaviour and is restricted only to structs and atom keys in maps.
-
-  As mentioned above, this works for atom keys in maps as well. Refer to the
-  `Map` module for more information on this.
-
-  Summing up:
-
-    * `user[:name]` is used by dynamic structures, is extensible and
-      does not raise on missing keys
-    * `user.name` is used by static structures, it is not extensible
-      and it will raise on missing keys
-
-  ## Accessors
-
-  While Elixir provides built-in syntax only for traversing dynamic
-  and static key-value structures, this module provides convenience
-  functions for traversing other structures, like tuples and lists,
-  to be used alongside `Kernel.put_in/2` in others.
-
-  For instance, given a user map with `:name` and `:languages` keys, here is how
-  to deeply traverse the map and convert all language names to uppercase:
-
-      iex> languages = [
-      ...>   %{name: "elixir", type: :functional},
-      ...>   %{name: "c", type: :procedural},
-      ...> ]
-      iex> user = %{name: "john", languages: languages}
-      iex> update_in user, [:languages, Access.all(), :name], &String.upcase/1
-      %{name: "john",
-        languages: [%{name: "ELIXIR", type: :functional},
-                    %{name: "C", type: :procedural}]}
-
-  See the functions `key/1`, `key!/1`, `elem/1`, and `all/0` for some of the
-  available accessors.
-
-  ## Implementing the Access behaviour for custom data structures
-
-  In order to be able to use the `Access` behaviour with custom data structures
-  (which have to be structs), such structures have to implement the `Access`
-  behaviour. For example, for a `User` struct, this would have to be done:
-
-      defmodule User do
-        defstruct [:name, :email]
-
-        @behaviour Access
-        # Implementation of the Access callbacks...
-      end
-
-  """
-
-  @type container :: keyword | struct | map
-  @type nil_container :: nil
-  @type any_container :: any
-  @type t :: container | nil_container | any_container
-  @type key :: any
-  @type value :: any
-
-  @type get_fun(data, get_value) ::
-        (:get, data, (term -> term) ->
-        {get_value, new_data :: container})
-
-  @type get_and_update_fun(data, get_value) ::
-        (:get_and_update, data, (term -> term) ->
-        {get_value, new_data :: container} | :pop)
-
-  @type access_fun(data, get_value) ::
-        get_fun(data, get_value) | get_and_update_fun(data, get_value)
-
-  @doc """
-  Invoked in order to access the value stored under `key` in the given term `term`.
-
-  This function should return `{:ok, value}` where `value` is the value under
-  `key` if the key exists in the term, or `:error` if the key does not exist in
-  the term.
-
-  Many of the functions defined in the `Access` module internally call this
-  function. This function is also used when the square-brackets access syntax
-  (`structure[key]`) is used: the `fetch/2` callback implemented by the module
-  that defines the `structure` struct is invoked and if it returns `{:ok,
-  value}` then `value` is returned, or if it returns `:error` then `nil` is
-  returned.
-
-  See the `Map.fetch/2` and `Keyword.fetch/2` implementations for examples of
-  how to implement this callback.
-  """
-  @callback fetch(term :: t, key) :: {:ok, value} | :error
-
-  @doc """
-  Invoked in order to access the value stored under `key` in the given term `term`,
-  defaulting to `default` if not present.
-
-  This function should return the value under `key` in `term` if there's
-  such key, otherwise `default`.
-
-  For most data structures, this can be implemented using `fetch/2` internally;
-  for example:
-
-      def get(structure, key, default) do
-        case fetch(structure, key) do
-          {:ok, value} -> value
-          :error       -> default
-        end
-      end
-
-  See the `Map.get/3` and `Keyword.get/3` implementations for examples of
-  how to implement this callback.
-  """
-  @callback get(term :: t, key, default :: value) :: value
-
-  @doc """
-  Invoked in order to access the value under `key` and update it at the same time.
-
-  The implementation of this callback should invoke `fun` with the value under
-  `key` in the passed structure `data`, or with `nil` if `key` is not present in it.
-  This function must return either `{get_value, update_value}` or `:pop`.
-
-  If the passed function returns `{get_value, update_value}`,
-  the return value of this callback should be `{get_value, new_data}`, where:
-  - `get_value` is the retrieved value (which can be operated on before being returned)
-  - `update_value` is the new value to be stored under `key`
-  - `new_data` is `data` after updating the value of `key` with `update_value`.
-
-  If the passed function returns `:pop`, the return value of this callback
-  must be `{value, new_data}` where `value` is the value under `key`
-  (or `nil` if not present) and `new_data` is `data` without `key`.
-
-  See the implementations of `Map.get_and_update/3` or `Keyword.get_and_update/3`
-  for more examples.
-  """
-  @callback get_and_update(data, key, (value -> {get_value, value} | :pop)) ::
-            {get_value, data} when get_value: var, data: container | any_container
-
-  @doc """
-  Invoked to "pop" the value under `key` out of the given data structure.
-
-  When `key` exists in the given structure `data`, the implementation should
-  return a `{value, new_data}` tuple where `value` is the value that was under
-  `key` and `new_data` is `term` without `key`.
-
-  When `key` is not present in the given structure, a tuple `{value, data}`
-  should be returned, where `value` is implementation-defined.
-
-  See the implementations for `Map.pop/3` or `Keyword.pop/3` for more examples.
-  """
-  @callback pop(data, key) :: {value, data} when data: container | any_container
-
-  defmacrop raise_undefined_behaviour(e, struct, top) do
-    quote do
-      stacktrace = System.stacktrace
-      e =
-        case stacktrace do
-          [unquote(top) | _] ->
-            %{unquote(e) | reason: "#{inspect unquote(struct)} does not implement the Access behaviour"}
-          _ ->
-            unquote(e)
-        end
-      reraise e, stacktrace
-    end
-  end
-
-  @doc """
-  Fetches the value for the given key in a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns `{:ok, value}` where `value` is the value under `key` if there is such
-  a key, or `:error` if `key` is not found.
-  """
-  @spec fetch(container, term) :: {:ok, term} | :error
-  @spec fetch(nil_container, any) :: :error
-  def fetch(container, key)
-
-  def fetch(%struct{} = container, key) do
-    struct.fetch(container, key)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :fetch, [^container, ^key], _}
-  end
-
-  def fetch(map, key) when is_map(map) do
-    case map do
-      %{^key => value} -> {:ok, value}
-      _ -> :error
-    end
-  end
-
-  def fetch(list, key) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {_, value} -> {:ok, value}
-      false -> :error
-    end
-  end
-
-  def fetch(list, key) when is_list(list) do
-    raise ArgumentError,
-      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
-  end
-
-  def fetch(nil, _key) do
-    :error
-  end
-
-  @doc """
-  Gets the value for the given key in a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns the value under `key` if there is such a key, or `default` if `key` is
-  not found.
-  """
-  @spec get(container, term, term) :: term
-  @spec get(nil_container, any, default) :: default when default: var
-  def get(container, key, default \\ nil)
-
-  def get(%{__struct__: struct} = container, key, default) do
-    try do
-      struct.fetch(container, key)
-    rescue
-      e in UndefinedFunctionError ->
-        raise_undefined_behaviour e, struct, {^struct, :fetch, [^container, ^key], _}
-    else
-      {:ok, value} -> value
-      :error -> default
-    end
-  end
-
-  def get(map, key, default) when is_map(map) do
-    case map do
-      %{^key => value} -> value
-      _ -> default
-    end
-  end
-
-  def get(list, key, default) when is_list(list) and is_atom(key) do
-    case :lists.keyfind(key, 1, list) do
-      {_, value} -> value
-      false -> default
-    end
-  end
-
-  def get(list, key, _default) when is_list(list) do
-    raise ArgumentError,
-      "the Access calls for keywords expect the key to be an atom, got: " <> inspect(key)
-  end
-
-  def get(nil, _key, default) do
-    default
-  end
-
-  @doc """
-  Gets and updates the given key in a `container` (a map, a keyword list,
-  a struct that implements the `Access` behaviour).
-
-  The `fun` argument receives the value of `key` (or `nil` if `key` is not
-  present in `container`) and must return a two-element tuple `{get_value, update_value}`:
-  the "get" value `get_value` (the retrieved value, which can be operated on before
-  being returned) and the new value to be stored under `key` (`update_value`).
-  `fun` may also return `:pop`, which means the current value
-  should be removed from the container and returned.
-
-  The returned value is a two-element tuple with the "get" value returned by
-  `fun` and a new container with the updated value under `key`.
-  """
-  @spec get_and_update(data, key, (value -> {get_value, value} | :pop)) ::
-        {get_value, data} when get_value: var, data: container
-  def get_and_update(container, key, fun)
-
-  def get_and_update(%{__struct__: struct} = container, key, fun) do
-    struct.get_and_update(container, key, fun)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :get_and_update, [^container, ^key, ^fun], _}
-  end
-
-  def get_and_update(map, key, fun) when is_map(map) do
-    Map.get_and_update(map, key, fun)
-  end
-
-  def get_and_update(list, key, fun) when is_list(list) do
-    Keyword.get_and_update(list, key, fun)
-  end
-
-  def get_and_update(nil, key, _fun) do
-    raise ArgumentError,
-      "could not put/update key #{inspect key} on a nil value"
-  end
-
-  @doc """
-  Removes the entry with a given key from a container (a map, keyword
-  list, or struct that implements the `Access` behaviour).
-
-  Returns a tuple containing the value associated with the key and the
-  updated container. `nil` is returned for the value if the key isn't
-  in the container.
-
-  ## Examples
-
-  With a map:
-
-      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :name)
-      {"Elixir", %{creator: "Valim"}}
-
-  A keyword list:
-
-      iex> Access.pop([name: "Elixir", creator: "Valim"], :name)
-      {"Elixir", [creator: "Valim"]}
-
-  An unknown key:
-
-      iex> Access.pop(%{name: "Elixir", creator: "Valim"}, :year)
-      {nil, %{creator: "Valim", name: "Elixir"}}
-
-  """
-  @spec pop(data, key) :: {value, data} when data: container
-  def pop(%{__struct__: struct} = container, key) do
-    struct.pop(container, key)
-  rescue
-    e in UndefinedFunctionError ->
-      raise_undefined_behaviour e, struct, {^struct, :pop, [^container, ^key], _}
-  end
-
-  def pop(map, key) when is_map(map) do
-    Map.pop(map, key)
-  end
-
-  def pop(list, key) when is_list(list) do
-    Keyword.pop(list, key)
-  end
-
-  def pop(nil, key) do
-    raise ArgumentError,
-      "could not pop key #{inspect key} on a nil value"
-  end
-
-  ## Accessors
-
-  @doc """
-  Returns a function that accesses the given key in a map/struct.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  The returned function uses the default value if the key does not exist.
-  This can be used to specify defaults and safely traverse missing keys:
-
-      iex> get_in(%{}, [Access.key(:user, %{}), Access.key(:name)])
-      nil
-
-  Such is also useful when using update functions, allowing us to introduce
-  values as we traverse the data structure for updates:
-
-      iex> put_in(%{}, [Access.key(:user, %{}), Access.key(:name)], "Mary")
-      %{user: %{name: "Mary"}}
-
-  ## Examples
-
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key(:unknown, %{}), Access.key(:name, "john")])
-      "john"
-      iex> get_and_update_in(map, [Access.key(:user), Access.key(:name)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key(:user), Access.key(:name)])
-      {"john", %{user: %{}}}
-
-  An error is raised if the accessed structure is not a map or a struct:
-
-      iex> get_in(nil, [Access.key(:foo)])
-      ** (BadMapError) expected a map, got: nil
-
-      iex> get_in([], [Access.key(:foo)])
-      ** (BadMapError) expected a map, got: []
-
-  """
-  @spec key(key, term) :: access_fun(data :: struct | map, get_value :: term)
-  def key(key, default \\ nil) do
-    fn
-      :get, data, next ->
-        next.(Map.get(data, key, default))
-      :get_and_update, data, next ->
-        value = Map.get(data, key, default)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-    end
-  end
-
-  @doc """
-  Returns a function that accesses the given key in a map/struct.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  The returned function raises if the key does not exist.
-
-  ## Examples
-
-      iex> map = %{user: %{name: "john"}}
-      iex> get_in(map, [Access.key!(:user), Access.key!(:name)])
-      "john"
-      iex> get_and_update_in(map, [Access.key!(:user), Access.key!(:name)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: %{name: "JOHN"}}}
-      iex> pop_in(map, [Access.key!(:user), Access.key!(:name)])
-      {"john", %{user: %{}}}
-      iex> get_in(map, [Access.key!(:user), Access.key!(:unknown)])
-      ** (KeyError) key :unknown not found in: %{name: \"john\"}
-
-  An error is raised if the accessed structure is not a map/struct:
-
-      iex> get_in([], [Access.key!(:foo)])
-      ** (RuntimeError) Access.key!/1 expected a map/struct, got: []
-
-  """
-  @spec key!(key) :: access_fun(data :: struct | map, get_value :: term)
-  def key!(key) do
-    fn
-      :get, %{} = data, next ->
-        next.(Map.fetch!(data, key))
-      :get_and_update, %{} = data, next ->
-        value = Map.fetch!(data, key)
-        case next.(value) do
-          {get, update} -> {get, Map.put(data, key, update)}
-          :pop -> {value, Map.delete(data, key)}
-        end
-      _op, data, _next ->
-        raise "Access.key!/1 expected a map/struct, got: #{inspect data}"
-    end
-  end
-
-  @doc ~S"""
-  Returns a function that accesses the element at the given index in a tuple.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  The returned function raises if `index` is out of bounds.
-
-  ## Examples
-
-      iex> map = %{user: {"john", 27}}
-      iex> get_in(map, [:user, Access.elem(0)])
-      "john"
-      iex> get_and_update_in(map, [:user, Access.elem(0)], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", %{user: {"JOHN", 27}}}
-      iex> pop_in(map, [:user, Access.elem(0)])
-      ** (RuntimeError) cannot pop data from a tuple
-
-  An error is raised if the accessed structure is not a tuple:
-
-      iex> get_in(%{}, [Access.elem(0)])
-      ** (RuntimeError) Access.elem/1 expected a tuple, got: %{}
-
-  """
-  @spec elem(non_neg_integer) :: access_fun(data :: tuple, get_value :: term)
-  def elem(index) when is_integer(index) do
-    pos = index + 1
-
-    fn
-      :get, data, next when is_tuple(data) ->
-        next.(:erlang.element(pos, data))
-      :get_and_update, data, next when is_tuple(data) ->
-        value = :erlang.element(pos, data)
-        case next.(value) do
-          {get, update} -> {get, :erlang.setelement(pos, data, update)}
-          :pop -> raise "cannot pop data from a tuple"
-        end
-      _op, data, _next ->
-        raise "Access.elem/1 expected a tuple, got: #{inspect data}"
-    end
-  end
-
-  @doc ~S"""
-  Returns a function that accesses all the elements in a list.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.all(), :name])
-      ["john", "mary"]
-      iex> get_and_update_in(list, [Access.all(), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {["john", "mary"], [%{name: "JOHN"}, %{name: "MARY"}]}
-      iex> pop_in(list, [Access.all(), :name])
-      {["john", "mary"], [%{}, %{}]}
-
-  Here is an example that traverses the list dropping even
-  numbers and multiplying odd numbers by 2:
-
-      iex> require Integer
-      iex> get_and_update_in([1, 2, 3, 4, 5], [Access.all], fn
-      ...>   num -> if Integer.is_even(num), do: :pop, else: {num, num * 2}
-      ...> end)
-      {[1, 2, 3, 4, 5], [2, 6, 10]}
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.all()])
-      ** (RuntimeError) Access.all/0 expected a list, got: %{}
-
-  """
-  @spec all() :: access_fun(data :: list, get_value :: list)
-  def all() do
-    &all/3
-  end
-
-  defp all(:get, data, next) when is_list(data) do
-    Enum.map(data, next)
-  end
-
-  defp all(:get_and_update, data, next) when is_list(data) do
-    all(data, next, _gets = [], _updates = [])
-  end
-
-  defp all(_op, data, _next) do
-    raise "Access.all/0 expected a list, got: #{inspect data}"
-  end
-
-  defp all([head | rest], next, gets, updates) do
-    case next.(head) do
-      {get, update} -> all(rest, next, [get | gets], [update | updates])
-      :pop -> all(rest, next, [head | gets], updates)
-    end
-  end
-
-  defp all([], _next, gets, updates) do
-    {:lists.reverse(gets), :lists.reverse(updates)}
-  end
-
-  @doc ~S"""
-  Returns a function that accesses the element at `index` (zero based) of a list.
-
-  The returned function is typically passed as an accessor to `Kernel.get_in/2`,
-  `Kernel.get_and_update_in/3`, and friends.
-
-  ## Examples
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.at(1), :name])
-      "mary"
-      iex> get_and_update_in(list, [Access.at(0), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {"john", [%{name: "JOHN"}, %{name: "mary"}]}
-
-  `at/1` can also be used to pop elements out of a list or
-  a key inside of a list:
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> pop_in(list, [Access.at(0)])
-      {%{name: "john"}, [%{name: "mary"}]}
-      iex> pop_in(list, [Access.at(0), :name])
-      {"john", [%{}, %{name: "mary"}]}
-
-  When the index is out of bounds, `nil` is returned and the update function is never called:
-
-      iex> list = [%{name: "john"}, %{name: "mary"}]
-      iex> get_in(list, [Access.at(10), :name])
-      nil
-      iex> get_and_update_in(list, [Access.at(10), :name], fn
-      ...>   prev -> {prev, String.upcase(prev)}
-      ...> end)
-      {nil, [%{name: "john"}, %{name: "mary"}]}
-
-  An error is raised for negative indexes:
-
-      iex> get_in([], [Access.at(-1)])
-      ** (FunctionClauseError) no function clause matching in Access.at/1
-
-  An error is raised if the accessed structure is not a list:
-
-      iex> get_in(%{}, [Access.at(1)])
-      ** (RuntimeError) Access.at/1 expected a list, got: %{}
-
-  """
-  @spec at(non_neg_integer) :: access_fun(data :: list, get_value :: term)
-  def at(index) when is_integer(index) and index >= 0 do
-    fn(op, data, next) -> at(op, data, index, next) end
-  end
-
-  defp at(:get, data, index, next) when is_list(data) do
-    data |> Enum.at(index) |> next.()
-  end
-
-  defp at(:get_and_update, data, index, next) when is_list(data) do
-    get_and_update_at(data, index, next, [])
-  end
-
-  defp at(_op, data, _index, _next) do
-    raise "Access.at/1 expected a list, got: #{inspect data}"
-  end
-
-  defp get_and_update_at([head | rest], 0, next, updates) do
-    case next.(head) do
-      {get, update} -> {get, :lists.reverse([update | updates], rest)}
-      :pop -> {head, :lists.reverse(updates, rest)}
-    end
-  end
-
-  defp get_and_update_at([head | rest], index, next, updates) do
-    get_and_update_at(rest, index - 1, next, [head | updates])
-  end
-
-  defp get_and_update_at([], _index, _next, updates) do
-    {nil, :lists.reverse(updates)}
-  end
-end

lib/elixir/lib/agent.ex

@@ -1,426 +0,0 @@
-defmodule Agent do
-  @moduledoc """
-  Agents are a simple abstraction around state.
-
-  Often in Elixir there is a need to share or store state that
-  must be accessed from different processes or by the same process
-  at different points in time.
-
-  The `Agent` module provides a basic server implementation that
-  allows state to be retrieved and updated via a simple API.
-
-  ## Examples
-
-  For example, in the Mix tool that ships with Elixir, we need
-  to keep a set of all tasks executed by a given project. Since
-  this set is shared, we can implement it with an agent:
-
-      defmodule Mix.TasksServer do
-        use Agent
-
-        def start_link do
-          Agent.start_link(fn -> MapSet.new end, name: __MODULE__)
-        end
-
-        @doc "Checks if the task has already executed"
-        def executed?(task, project) do
-          item = {task, project}
-          Agent.get(__MODULE__, fn set ->
-            item in set
-          end)
-        end
-
-        @doc "Marks a task as executed"
-        def put_task(task, project) do
-          item = {task, project}
-          Agent.update(__MODULE__, &MapSet.put(&1, item))
-        end
-
-        @doc "Resets the executed tasks and returns the previous list of tasks"
-        def take_all() do
-          Agent.get_and_update(__MODULE__, fn set ->
-            {Enum.into(set, []), MapSet.new}
-          end)
-        end
-      end
-
-  Agents provide a segregation between the client and server APIs (similar
-  to GenServers). In particular, the anonymous functions given to the `Agent`
-  are executed inside the agent (the server). This distinction is important
-  because you may want to avoid expensive operations inside the agent,
-  as they will effectively block the agent until the request is fulfilled.
-
-  Consider these two examples:
-
-      # Compute in the agent/server
-      def get_something(agent) do
-        Agent.get(agent, fn state -> do_something_expensive(state) end)
-      end
-
-      # Compute in the agent/client
-      def get_something(agent) do
-        Agent.get(agent, &(&1)) |> do_something_expensive()
-      end
-
-  The first function blocks the agent. The second function copies all the state
-  to the client and then executes the operation in the client. One aspect to
-  consider is whether the data is large enough to require processing in the server,
-  at least initially, or small enough to be sent to the client cheaply. Another
-  factor is whether the data needs to be processed atomically: getting the
-  state and calling `do_something_expensive(state)` outside of the agent means
-  that the agent's state can be updated in the meantime. This is specially
-  important in case of updates as computing the new state in the client rather
-  than in the server can lead to race conditions if multiple clients are trying
-  to update the same state to different values.
-
-  Finally note `use Agent` defines a `child_spec/1` function, allowing the
-  defined module to be put under a supervision tree. The generated
-  `child_spec/1` can be customized with the following options:
-
-    * `:id` - the child specification id, defauts to the current module
-    * `:start` - how to start the child process (defaults to calling `__MODULE__.start_link/1`)
-    * `:restart` - when the child should be restarted, defaults to `:permanent`
-    * `:shutdown` - how to shut down the child
-
-  For example:
-
-      use Agent, restart: :transient, shutdown: 10_000
-
-  See the `Supervisor` docs for more information.
-
-  ## Name registration
-
-  An agent is bound to the same name registration rules as GenServers.
-  Read more about it in the `GenServer` documentation.
-
-  ## A word on distributed agents
-
-  It is important to consider the limitations of distributed agents. Agents
-  provide two APIs, one that works with anonymous functions and another
-  that expects an explicit module, function, and arguments.
-
-  In a distributed setup with multiple nodes, the API that accepts anonymous
-  functions only works if the caller (client) and the agent have the same
-  version of the caller module.
-
-  Keep in mind this issue also shows up when performing "rolling upgrades"
-  with agents. By rolling upgrades we mean the following situation: you wish
-  to deploy a new version of your software by *shutting down* some of your
-  nodes and replacing them with nodes running a new version of the software.
-  In this setup, part of your environment will have one version of a given
-  module and the other part another version (the newer one) of the same module.
-
-  The best solution is to simply use the explicit module, function, and arguments
-  APIs when working with distributed agents.
-
-  ## Hot code swapping
-
-  An agent can have its code hot swapped live by simply passing a module,
-  function, and arguments tuple to the update instruction. For example, imagine
-  you have an agent named `:sample` and you want to convert its inner state
-  from a keyword list to a map. It can be done with the following
-  instruction:
-
-      {:update, :sample, {:advanced, {Enum, :into, [%{}]}}}
-
-  The agent's state will be added to the given list of arguments (`[%{}]`) as
-  the first argument.
-  """
-
-  @typedoc "Return values of `start*` functions"
-  @type on_start :: {:ok, pid} | {:error, {:already_started, pid} | term}
-
-  @typedoc "The agent name"
-  @type name :: atom | {:global, term} | {:via, module, term}
-
-  @typedoc "The agent reference"
-  @type agent :: pid | {atom, node} | name
-
-  @typedoc "The agent state"
-  @type state :: term
-
-  @doc false
-  def child_spec(arg) do
-    %{
-      id: Agent,
-      start: {Agent, :start_link, [arg]}
-    }
-  end
-
-  @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      spec = [
-        id: opts[:id] || __MODULE__,
-        start: Macro.escape(opts[:start]) || quote(do: {__MODULE__, :start_link, [arg]}),
-        restart: opts[:restart] || :permanent,
-        shutdown: opts[:shutdown] || 5000,
-        type: :worker
-      ]
-
-      @doc false
-      def child_spec(arg) do
-        %{unquote_splicing(spec)}
-      end
-
-      defoverridable child_spec: 1
-    end
-  end
-
-  @doc """
-  Starts an agent linked to the current process with the given function.
-
-  This is often used to start the agent as part of a supervision tree.
-
-  Once the agent is spawned, the given function `fun` is invoked and its return
-  value is used as the agent state. Note that `start_link/2` does not return
-  until the given function has returned.
-
-  ## Options
-
-  The `:name` option is used for registration as described in the module
-  documentation.
-
-  If the `:timeout` option is present, the agent is allowed to spend at most
-  the given number of milliseconds on initialization 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.
-
-  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, the function returns
-  `{:ok, pid}`, where `pid` is the PID of the server. If an agent with the
-  specified name already exists, the function returns
-  `{:error, {:already_started, pid}}` with the PID of that process.
-
-  If the given function callback fails, the function returns `{:error, reason}`.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
-      iex> {:error, {exception, _stacktrace}} = Agent.start(fn -> raise "oops" end)
-      iex> exception
-      %RuntimeError{message: "oops"}
-
-  """
-  @spec start_link((() -> term), GenServer.options) :: on_start
-  def start_link(fun, options \\ []) when is_function(fun, 0) do
-    GenServer.start_link(Agent.Server, fun, options)
-  end
-
-  @doc """
-  Starts an agent linked to the current process.
-
-  Same as `start_link/2` but a module, function, and arguments are expected
-  instead of an anonymous function; `fun` in `module` will be called with the
-  given arguments `args` to initialize the state.
-  """
-  @spec start_link(module, atom, [any], GenServer.options) :: on_start
-  def start_link(module, fun, args, options \\ []) do
-    GenServer.start_link(Agent.Server, {module, fun, args}, options)
-  end
-
-  @doc """
-  Starts an agent process without links (outside of a supervision tree).
-
-  See `start_link/2` for more information.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start(fn -> 42 end)
-      iex> Agent.get(pid, fn(state) -> state end)
-      42
-
-  """
-  @spec start((() -> term), GenServer.options) :: on_start
-  def start(fun, options \\ []) when is_function(fun, 0) do
-    GenServer.start(Agent.Server, fun, options)
-  end
-
-  @doc """
-  Starts an agent without links with the given module, function, and arguments.
-
-  See `start_link/4` for more information.
-  """
-  @spec start(module, atom, [any], GenServer.options) :: on_start
-  def start(module, fun, args, options \\ []) do
-    GenServer.start(Agent.Server, {module, fun, args}, options)
-  end
-
-  @doc """
-  Gets an agent value via the given anonymous function.
-
-  The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The result of the function invocation is
-  returned from this function.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get(pid, fn state -> state end)
-      42
-
-  """
-  @spec get(agent, (state -> a), timeout) :: a when a: var
-  def get(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
-    GenServer.call(agent, {:get, fun}, timeout)
-  end
-
-  @doc """
-  Gets an agent value via the given function.
-
-  Same as `get/3` but a module, function, and arguments are expected
-  instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-  """
-  @spec get(agent, module, atom, [term], timeout) :: any
-  def get(agent, module, fun, args, timeout \\ 5000) do
-    GenServer.call(agent, {:get, {module, fun, args}}, timeout)
-  end
-
-  @doc """
-  Gets and updates the agent state in one operation via the given anonymous
-  function.
-
-  The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The function must return a tuple with two
-  elements, the first being the value to return (that is, the "get" value)
-  and the second one being the new state of the agent.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.get_and_update(pid, fn state -> {state, state + 1} end)
-      42
-      iex> Agent.get(pid, fn state -> state end)
-      43
-
-  """
-  @spec get_and_update(agent, (state -> {a, state}), timeout) :: a when a: var
-  def get_and_update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
-    GenServer.call(agent, {:get_and_update, fun}, timeout)
-  end
-
-  @doc """
-  Gets and updates the agent state in one operation via the given function.
-
-  Same as `get_and_update/3` but a module, function, and arguments are expected
-  instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-  """
-  @spec get_and_update(agent, module, atom, [term], timeout) :: any
-  def get_and_update(agent, module, fun, args, timeout \\ 5000) do
-    GenServer.call(agent, {:get_and_update, {module, fun, args}}, timeout)
-  end
-
-  @doc """
-  Updates the agent state via the given anonymous function.
-
-  The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
-
-  This function always returns `:ok`.
-
-  `timeout` is an integer greater than zero which specifies how many
-  milliseconds are allowed before the agent executes the function and returns
-  the result value, or the atom `:infinity` to wait indefinitely. If no result
-  is received within the specified time, the function call fails and the caller
-  exits.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.update(pid, fn state -> state + 1 end)
-      :ok
-      iex> Agent.get(pid, fn state -> state end)
-      43
-
-  """
-  @spec update(agent, (state -> state), timeout) :: :ok
-  def update(agent, fun, timeout \\ 5000) when is_function(fun, 1) do
-    GenServer.call(agent, {:update, fun}, timeout)
-  end
-
-  @doc """
-  Updates the agent state via the given function.
-
-  Same as `update/3` but a module, function, and arguments are expected
-  instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-  """
-  @spec update(agent, module, atom, [term], timeout) :: :ok
-  def update(agent, module, fun, args, timeout \\ 5000) do
-    GenServer.call(agent, {:update, {module, fun, args}}, timeout)
-  end
-
-  @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
-
-  The function `fun` is sent to the `agent` which invokes the function
-  passing the agent state. The return value of `fun` becomes the new
-  state of the agent.
-
-  Note that `cast` returns `:ok` immediately, regardless of whether `agent` (or
-  the node it should live on) exists.
-  """
-  @spec cast(agent, (state -> state)) :: :ok
-  def cast(agent, fun) when is_function(fun, 1) do
-    GenServer.cast(agent, {:cast, fun})
-  end
-
-  @doc """
-  Performs a cast (*fire and forget*) operation on the agent state.
-
-  Same as `cast/2` but a module, function, and arguments are expected
-  instead of an anonymous function. The state is added as first
-  argument to the given list of arguments.
-  """
-  @spec cast(agent, module, atom, [term]) :: :ok
-  def cast(agent, module, fun, args) do
-    GenServer.cast(agent, {:cast, {module, fun, args}})
-  end
-
-  @doc """
-  Synchronously stops the agent with the given `reason`.
-
-  It returns `:ok` if the agent terminates with the given
-  reason. If the agent terminates with another reason, the call will
-  exit.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report will be logged.
-
-  ## Examples
-
-      iex> {:ok, pid} = Agent.start_link(fn -> 42 end)
-      iex> Agent.stop(pid)
-      :ok
-
-  """
-  @spec stop(agent, reason :: term, timeout) :: :ok
-  def stop(agent, reason \\ :normal, timeout \\ :infinity) do
-    GenServer.stop(agent, reason, timeout)
-  end
-end

lib/elixir/lib/agent/server.ex

@@ -1,59 +0,0 @@
-defmodule Agent.Server do
-  @moduledoc false
-
-  use GenServer
-
-  def init(fun) do
-    _ = initial_call(fun)
-    {:ok, run(fun, [])}
-  end
-
-  def handle_call({:get, fun}, _from, state) do
-    {:reply, run(fun, [state]), state}
-  end
-
-  def handle_call({:get_and_update, fun}, _from, state) do
-    case run(fun, [state]) do
-      {reply, state} -> {:reply, reply, state}
-      other          -> {:stop, {:bad_return_value, other}, state}
-    end
-  end
-
-  def handle_call({:update, fun}, _from, state) do
-    {:reply, :ok, run(fun, [state])}
-  end
-
-  def handle_call(msg, from, state) do
-    super(msg, from, state)
-  end
-
-  def handle_cast({:cast, fun}, state) do
-    {:noreply, run(fun, [state])}
-  end
-
-  def handle_cast(msg, state) do
-    super(msg, state)
-  end
-
-  def code_change(_old, state, fun) do
-    {:ok, run(fun, [state])}
-  end
-
-  defp initial_call(mfa) do
-    _ = Process.put(:"$initial_call", get_initial_call(mfa))
-    :ok
-  end
-
-  defp get_initial_call(fun) when is_function(fun, 0) do
-    {:module, module} = :erlang.fun_info(fun, :module)
-    {:name, name} = :erlang.fun_info(fun, :name)
-    {module, name, 0}
-  end
-
-  defp get_initial_call({mod, fun, args}) do
-    {mod, fun, length(args)}
-  end
-
-  defp run({m, f, a}, extra), do: apply(m, f, extra ++ a)
-  defp run(fun, extra), do: apply(fun, extra)
-end

lib/elixir/lib/application.ex

@@ -1,561 +0,0 @@
-defmodule Application do
-  @moduledoc """
-  A module for working with applications and defining application callbacks.
-
-  In Elixir (actually, in Erlang/OTP), an application is a component
-  implementing some specific functionality, that can be started and stopped
-  as a unit, and which can be re-used in other systems.
-
-  Applications are defined with an application file named `APP.app` where
-  `APP` is the application name, usually in `underscore_case`. The application
-  file must reside in the same `ebin` directory as the compiled modules of the
-  application.
-
-  In Elixir, Mix is responsible for compiling your source code and
-  generating your application `.app` file. Furthermore, Mix is also
-  responsible for configuring, starting and stopping your application
-  and its dependencies. For this reason, this documentation will focus
-  on the remaining aspects of your application: the application environment
-  and the application callback module.
-
-  You can learn more about Mix generation of `.app` files by typing
-  `mix help compile.app`.
-
-  ## Application environment
-
-  Once an application is started, OTP provides an application environment
-  that can be used to configure the application.
-
-  Assuming you are inside a Mix project, you can edit the `application/0`
-  function in the `mix.exs` file to the following:
-
-      def application do
-        [env: [hello: :world]]
-      end
-
-  In the application function, we can define the default environment values
-  for our application. By starting your application with `iex -S mix`, you
-  can access the default value:
-
-      Application.get_env(:APP_NAME, :hello)
-      #=> :world
-
-  It is also possible to put and delete values from the application value,
-  including new values that are not defined in the environment file (although
-  this should be avoided).
-
-  Keep in mind that each application is responsible for its environment.
-  Do not use the functions in this module for directly accessing or modifying
-  the environment of other applications (as it may lead to inconsistent
-  data in the application environment).
-
-  ## Application module callback
-
-  Often times, an application defines a supervision tree that must be started
-  and stopped when the application starts and stops. For such, we need to
-  define an application module callback. The first step is to define the
-  module callback in the application definition in the `mix.exs` file:
-
-      def application do
-        [mod: {MyApp, []}]
-      end
-
-  Our application now requires the `MyApp` module to provide an application
-  callback. This can be done by invoking `use Application` in that module and
-  defining a `start/2` callback, for example:
-
-      defmodule MyApp do
-        use Application
-
-        def start(_type, _args) do
-          MyApp.Supervisor.start_link()
-        end
-      end
-
-  `start/2` typically returns `{:ok, pid}` or `{:ok, pid, state}` where
-  `pid` identifies the supervision tree and `state` is the application state.
-  `args` is the second element of the tuple given to the `:mod` option.
-
-  The `type` argument passed to `start/2` is usually `:normal` unless in a
-  distributed setup where application takeovers and failovers are configured.
-  This particular aspect of applications is explained in more detail in the
-  OTP documentation:
-
-    * [`:application` module](http://www.erlang.org/doc/man/application.html)
-    * [Applications – OTP Design Principles](http://www.erlang.org/doc/design_principles/applications.html)
-
-  A developer may also implement the `stop/1` callback (automatically defined
-  by `use Application`) which does any application cleanup. It receives the
-  application state and can return any value. Note that shutting down the
-  supervisor is automatically handled by the VM.
-
-  An application without a supervision tree doesn't define an application
-  module callback in the application definition in `mix.exs` file. Even though
-  there is no module with application callbacks such as `start/2` and
-  `stop/1`, the application can be started and stopped the same way as an
-  application with a supervision tree.
-  """
-
-  @doc """
-  Called when an application is started.
-
-  This function is called when an application is started using
-  `Application.start/2` (and functions on top of that, such as
-  `Application.ensure_started/2`). This function should start the top-level
-  process of the application (which should be the top supervisor of the
-  application's supervision tree if the application follows the OTP design
-  principles around supervision).
-
-  `start_type` defines how the application is started:
-
-    * `:normal` - used if the startup is a normal startup or if the application
-      is distributed and is started on the current node because of a failover
-      from another node and the application specification key `:start_phases`
-      is `:undefined`.
-    * `{:takeover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on the node `node`.
-    * `{:failover, node}` - used if the application is distributed and is
-      started on the current node because of a failover on node `node`, and the
-      application specification key `:start_phases` is not `:undefined`.
-
-  `start_args` are the arguments passed to the application in the `:mod`
-  specification key (e.g., `mod: {MyApp, [:my_args]}`).
-
-  This function should either return `{:ok, pid}` or `{:ok, pid, state}` if
-  startup is successful. `pid` should be the PID of the top supervisor. `state`
-  can be an arbitrary term, and if omitted will default to `[]`; if the
-  application is later stopped, `state` is passed to the `stop/1` callback (see
-  the documentation for the `c:stop/1` callback for more information).
-
-  `use Application` provides no default implementation for the `start/2`
-  callback.
-  """
-  @callback start(start_type, start_args :: term) ::
-    {:ok, pid} |
-    {:ok, pid, state} |
-    {:error, reason :: term}
-
-  @doc """
-  Called when an application is stopped.
-
-  This function is called when an application has stopped, i.e., when its
-  supervision tree has been stopped. It should do the opposite of what the
-  `start/2` callback did, and should perform any necessary cleanup. The return
-  value of this callback is ignored.
-
-  `state` is the return value of the `start/2` callback or the return value of
-  the `prep_stop/1` function if the application module defines such a function.
-
-  `use Application` defines a default implementation of this function which does
-  nothing and just returns `:ok`.
-  """
-  @callback stop(state) :: term
-
-  @doc """
-  Start an application in synchronous phases.
-
-  This function is called after `start/2` finishes but before
-  `Application.start/2` returns. It will be called once for every start phase
-  defined in the application's (and any included applications') specification,
-  in the order they are listed in.
-  """
-  @callback start_phase(phase :: term, start_type, phase_args :: term) ::
-    :ok |
-    {:error, reason :: term}
-
-  @optional_callbacks start_phase: 3
-
-  @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behaviour Application
-
-      @doc false
-      def stop(_state) do
-        :ok
-      end
-
-      defoverridable Application
-    end
-  end
-
-  @type app :: atom
-  @type key :: atom
-  @type value :: term
-  @type state :: term
-  @type start_type :: :permanent | :transient | :temporary
-
-  @application_keys [:description, :id, :vsn, :modules, :maxP, :maxT, :registered,
-                     :included_applications, :applications, :mod, :start_phases]
-
-  @doc """
-  Returns the spec for `app`.
-
-  The following keys are returned:
-
-    * #{Enum.map_join @application_keys, "\n  * ", &inspect/1}
-
-  Note the environment is not returned as it can be accessed via
-  `fetch_env/2`. Returns `nil` if the application is not loaded.
-  """
-  @spec spec(app) :: [{key, value}] | nil
-  def spec(app) do
-    case :application.get_all_key(app) do
-      {:ok, info} -> :lists.keydelete(:env, 1, info)
-      :undefined  -> nil
-    end
-  end
-
-  @doc """
-  Returns the value for `key` in `app`'s specification.
-
-  See `spec/1` for the supported keys. If the given
-  specification parameter does not exist, this function
-  will raise. Returns `nil` if the application is not loaded.
-  """
-  @spec spec(app, key) :: value | nil
-  def spec(app, key) when key in @application_keys do
-    case :application.get_key(app, key) do
-      {:ok, value} -> value
-      :undefined -> nil
-    end
-  end
-
-  @doc """
-  Gets the application for the given module.
-
-  The application is located by analyzing the spec
-  of all loaded applications. Returns `nil` if
-  the module is not listed in any application spec.
-  """
-  @spec get_application(atom) :: atom | nil
-  def get_application(module) when is_atom(module) do
-    case :application.get_application(module) do
-      {:ok, app} -> app
-      :undefined -> nil
-    end
-  end
-
-  @doc """
-  Returns all key-value pairs for `app`.
-  """
-  @spec get_all_env(app) :: [{key, value}]
-  def get_all_env(app) do
-    :application.get_all_env(app)
-  end
-
-  @doc """
-  Returns the value for `key` in `app`'s environment.
-
-  If the configuration parameter does not exist, the function returns the
-  `default` value.
-  """
-  @spec get_env(app, key, value) :: value
-  def get_env(app, key, default \\ nil) do
-    :application.get_env(app, key, default)
-  end
-
-  @doc """
-  Returns the value for `key` in `app`'s environment in a tuple.
-
-  If the configuration parameter does not exist, the function returns `:error`.
-  """
-  @spec fetch_env(app, key) :: {:ok, value} | :error
-  def fetch_env(app, key) do
-    case :application.get_env(app, key) do
-      {:ok, value} -> {:ok, value}
-      :undefined -> :error
-    end
-  end
-
-  @doc """
-  Returns the value for `key` in `app`'s environment.
-
-  If the configuration parameter does not exist, raises `ArgumentError`.
-  """
-  @spec fetch_env!(app, key) :: value | no_return
-  def fetch_env!(app, key) do
-    case fetch_env(app, key) do
-      {:ok, value} -> value
-      :error ->
-        raise ArgumentError,
-          "application #{inspect app} is not loaded, " <>
-          "or the configuration parameter #{inspect key} is not set"
-    end
-  end
-
-  @doc """
-  Puts the `value` in `key` for the given `app`.
-
-  ## Options
-
-    * `:timeout` - the timeout for the change (defaults to `5_000` milliseconds)
-    * `:persistent` - persists the given value on application load and reloads
-
-  If `put_env/4` is called before the application is loaded, the application
-  environment values specified in the `.app` file will override the ones
-  previously set.
-
-  The persistent option can be set to `true` when there is a need to guarantee
-  parameters set with this function will not be overridden by the ones defined
-  in the application resource file on load. This means persistent values will
-  stick after the application is loaded and also on application reload.
-  """
-  @spec put_env(app, key, value, [timeout: timeout, persistent: boolean]) :: :ok
-  def put_env(app, key, value, opts \\ []) do
-    :application.set_env(app, key, value, opts)
-  end
-
-  @doc """
-  Deletes the `key` from the given `app` environment.
-
-  See `put_env/4` for a description of the options.
-  """
-  @spec delete_env(app, key, [timeout: timeout, persistent: boolean]) :: :ok
-  def delete_env(app, key, opts \\ []) do
-    :application.unset_env(app, key, opts)
-  end
-
-  @doc """
-  Ensures the given `app` is started.
-
-  Same as `start/2` but returns `:ok` if the application was already
-  started. This is useful in scripts and in test setup, where test
-  applications need to be explicitly started:
-
-      :ok = Application.ensure_started(:my_test_dep)
-
-  """
-  @spec ensure_started(app, start_type) :: :ok | {:error, term}
-  def ensure_started(app, type \\ :temporary) when is_atom(app) do
-    :application.ensure_started(app, type)
-  end
-
-  @doc """
-  Ensures the given `app` and its applications are started.
-
-  Same as `start/2` but also starts the applications listed under
-  `:applications` in the `.app` file in case they were not previously
-  started.
-  """
-  @spec ensure_all_started(app, start_type) :: {:ok, [app]} | {:error, {app, term}}
-  def ensure_all_started(app, type \\ :temporary) when is_atom(app) do
-    :application.ensure_all_started(app, type)
-  end
-
-  @doc """
-  Starts the given `app`.
-
-  If the `app` is not loaded, the application will first be loaded using `load/1`.
-  Any included application, defined in the `:included_applications` key of the
-  `.app` file will also be loaded, but they won't be started.
-
-  Furthermore, all applications listed in the `:applications` key must be explicitly
-  started before this application is. If not, `{:error, {:not_started, app}}` is
-  returned, where `app` is the name of the missing application.
-
-  In case you want to automatically load **and start** all of `app`'s dependencies,
-  see `ensure_all_started/2`.
-
-  The `type` argument specifies the type of the application:
-
-    * `:permanent` - if `app` terminates, all other applications and the entire
-      node are also terminated.
-
-    * `:transient` - if `app` terminates with `:normal` reason, it is reported
-      but no other applications are terminated. If a transient application
-      terminates abnormally, all other applications and the entire node are
-      also terminated.
-
-    * `:temporary` - if `app` terminates, it is reported but no other
-      applications are terminated (the default).
-
-  Note that it is always possible to stop an application explicitly by calling
-  `stop/1`. Regardless of the type of the application, no other applications will
-  be affected.
-
-  Note also that the `:transient` type is of little practical use, since when a
-  supervision tree terminates, the reason is set to `:shutdown`, not `:normal`.
-  """
-  @spec start(app, start_type) :: :ok | {:error, term}
-  def start(app, type \\ :temporary) when is_atom(app) do
-    :application.start(app, type)
-  end
-
-  @doc """
-  Stops the given `app`.
-
-  When stopped, the application is still loaded.
-  """
-  @spec stop(app) :: :ok | {:error, term}
-  def stop(app) do
-    :application.stop(app)
-  end
-
-  @doc """
-  Loads the given `app`.
-
-  In order to be loaded, an `.app` file must be in the load paths.
-  All `:included_applications` will also be loaded.
-
-  Loading the application does not start it nor load its modules, but
-  it does load its environment.
-  """
-  @spec load(app) :: :ok | {:error, term}
-  def load(app) when is_atom(app) do
-    :application.load(app)
-  end
-
-  @doc """
-  Unloads the given `app`.
-
-  It will also unload all `:included_applications`.
-  Note that the function does not purge the application modules.
-  """
-  @spec unload(app) :: :ok | {:error, term}
-  def unload(app) when is_atom(app) do
-    :application.unload(app)
-  end
-
-  @doc """
-  Gets the directory for app.
-
-  This information is returned based on the code path. Here is an
-  example:
-
-      File.mkdir_p!("foo/ebin")
-      Code.prepend_path("foo/ebin")
-      Application.app_dir(:foo)
-      #=> "foo"
-
-  Even though the directory is empty and there is no `.app` file
-  it is considered the application directory based on the name
-  "foo/ebin". The name may contain a dash `-` which is considered
-  to be the app version and it is removed for the lookup purposes:
-
-      File.mkdir_p!("bar-123/ebin")
-      Code.prepend_path("bar-123/ebin")
-      Application.app_dir(:bar)
-      #=> "bar-123"
-
-  For more information on code paths, check the `Code` module in
-  Elixir and also Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html).
-  """
-  @spec app_dir(app) :: String.t
-  def app_dir(app) when is_atom(app) do
-    case :code.lib_dir(app) do
-      lib when is_list(lib) -> IO.chardata_to_string(lib)
-      {:error, :bad_name} -> raise ArgumentError, "unknown application: #{inspect app}"
-    end
-  end
-
-  @doc """
-  Returns the given path inside `app_dir/1`.
-  """
-  @spec app_dir(app, String.t | [String.t]) :: String.t
-  def app_dir(app, path) when is_binary(path) do
-    Path.join(app_dir(app), path)
-  end
-  def app_dir(app, path) when is_list(path) do
-    Path.join([app_dir(app) | path])
-  end
-
-  @doc """
-  Returns a list with information about the applications which are currently running.
-  """
-  @spec started_applications(timeout) :: [tuple]
-  def started_applications(timeout \\ 5000) do
-    :application.which_applications(timeout)
-  end
-
-  @doc """
-  Returns a list with information about the applications which have been loaded.
-  """
-  @spec loaded_applications :: [tuple]
-  def loaded_applications do
-    :application.loaded_applications
-  end
-
-  @doc """
-  Formats the error reason returned by `start/2`,
-  `ensure_started/2`, `stop/1`, `load/1` and `unload/1`,
-  returns a string.
-  """
-  @spec format_error(any) :: String.t
-  def format_error(reason) do
-    try do
-      do_format_error(reason)
-    catch
-      # A user could create an error that looks like a built-in one
-      # causing an error.
-      :error, _ ->
-        inspect(reason)
-    end
-  end
-
-  # exit(:normal) call is special cased, undo the special case.
-  defp do_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
-    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
-    Exception.format_exit({reason, {mod, :start, args}})
-  end
-
-  # bad return value
-  defp do_format_error({:bad_return, {{mod, :start, args}, return}}) do
-    Exception.format_mfa(mod, :start, args) <>
-      " returned a bad value: " <> inspect(return)
-  end
-
-  defp do_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
-    "not started application #{app}"
-  end
-
-  defp do_format_error({:bad_application, app}) do
-    "bad application: #{inspect(app)}"
-  end
-
-  defp do_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
-    "not loaded application #{app}"
-  end
-
-  defp do_format_error({:invalid_restart_type, restart}) do
-    "invalid application restart type: #{inspect(restart)}"
-  end
-
-  defp do_format_error({:invalid_name, name}) do
-    "invalid application name: #{inspect(name)}"
-  end
-
-  defp do_format_error({:invalid_options, opts}) do
-    "invalid application options: #{inspect(opts)}"
-  end
-
-  defp do_format_error({:badstartspec, spec}) do
-    "bad application start specs: #{inspect(spec)}"
-  end
-
-  defp do_format_error({'no such file or directory', file}) do
-    "could not find application file: #{file}"
-  end
-
-  defp do_format_error(reason) do
-    Exception.format_exit(reason)
-  end
-end

lib/elixir/lib/atom.ex

@@ -1,45 +0,0 @@
-defmodule Atom do
-  @moduledoc """
-  Convenience functions for working with atoms.
-
-  See also `Kernel.is_atom/1`.
-  """
-
-  @doc """
-  Converts an atom to a string.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_string(:foo)
-      "foo"
-
-  """
-  @spec to_string(atom) :: String.t
-  def to_string(atom) do
-    :erlang.atom_to_binary(atom, :utf8)
-  end
-
-  @doc """
-  Converts an atom to a charlist.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> Atom.to_charlist(:"An atom")
-      'An atom'
-
-  """
-  @spec to_charlist(atom) :: charlist
-  def to_charlist(atom) do
-    :erlang.atom_to_list(atom)
-  end
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(atom) :: charlist
-  def to_char_list(atom), do: Atom.to_charlist(atom)
-end

lib/elixir/lib/behaviour.ex

@@ -1,106 +0,0 @@
-defmodule Behaviour do
-  @moduledoc """
-  This module has been deprecated.
-
-  Instead of `defcallback/1` and `defmacrocallback/1`, the `@callback` and
-  `@macrocallback` module attributes can be used (respectively). See the
-  documentation for `Module` for more information on these attributes.
-
-  Instead of `MyModule.__behaviour__(:callbacks)`,
-  `MyModule.behaviour_info(:callbacks)` can be used.
-  """
-
-  @doc """
-  Defines a function callback according to the given type specification.
-  """
-  defmacro defcallback(spec) do
-    do_defcallback(:def, split_spec(spec, quote(do: term)))
-  end
-
-  @doc """
-  Defines a macro callback according to the given type specification.
-  """
-  defmacro defmacrocallback(spec) do
-    do_defcallback(:defmacro, split_spec(spec, quote(do: Macro.t)))
-  end
-
-  defp split_spec({:when, _, [{:::, _, [spec, return]}, guard]}, _default) do
-    {spec, return, guard}
-  end
-
-  defp split_spec({:when, _, [spec, guard]}, default) do
-    {spec, default, guard}
-  end
-
-  defp split_spec({:::, _, [spec, return]}, _default) do
-    {spec, return, []}
-  end
-
-  defp split_spec(spec, default) do
-    {spec, default, []}
-  end
-
-  defp do_defcallback(kind, {spec, return, guards}) do
-    case Macro.decompose_call(spec) do
-      {name, args} ->
-        do_callback(kind, name, args, return, guards)
-      _ ->
-        raise ArgumentError, "invalid syntax in #{kind}callback #{Macro.to_string(spec)}"
-    end
-  end
-
-  defp do_callback(kind, name, args, return, guards) do
-    :lists.foreach fn
-      {:::, _, [left, right]} ->
-        ensure_not_default(left)
-        ensure_not_default(right)
-        left
-      other ->
-        ensure_not_default(other)
-        other
-    end, args
-
-    spec =
-      quote do
-        unquote(name)(unquote_splicing(args)) :: unquote(return) when unquote(guards)
-      end
-
-    case kind do
-      :def -> quote(do: @callback unquote(spec))
-      :defmacro -> quote(do: @macrocallback unquote(spec))
-    end
-  end
-
-  defp ensure_not_default({:\\, _, [_, _]}) do
-    raise ArgumentError, "default arguments \\\\ not supported in defcallback/defmacrocallback"
-  end
-
-  defp ensure_not_default(_), do: :ok
-
-  @doc false
-  defmacro __using__(_) do
-    quote do
-      warning =
-        "the Behaviour module is deprecated. Instead of using this module, " <>
-        "use the @callback and @macrocallback module attributes. See the " <>
-        "documentation for Module for more information on these attributes"
-      IO.warn(warning)
-
-      @doc false
-      def __behaviour__(:callbacks) do
-        __MODULE__.behaviour_info(:callbacks)
-      end
-
-      def __behaviour__(:docs) do
-        for {tuple, line, kind, docs} <- Code.get_docs(__MODULE__, :callback_docs) do
-          case kind do
-            :callback -> {tuple, line, :def, docs}
-            :macrocallback -> {tuple, line, :defmacro, docs}
-          end
-        end
-      end
-
-      import unquote(__MODULE__)
-    end
-  end
-end

lib/elixir/lib/bitwise.ex

@@ -1,213 +0,0 @@
-defmodule Bitwise do
-  @moduledoc """
-  A set of macros that perform calculations on bits.
-
-  The macros in this module come in two flavors: named or
-  operators. For example:
-
-      iex> use Bitwise
-      iex> bnot 1   # named
-      -2
-      iex> 1 &&& 1  # operator
-      1
-
-  If you prefer to use only operators or skip them, you can
-  pass the following options:
-
-    * `:only_operators` - includes only operators
-    * `:skip_operators` - skips operators
-
-  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:
-
-      iex> use Bitwise
-      iex> odd? = fn int when band(int, 1) == 1 -> true; _ -> false end
-      iex> odd?.(1)
-      true
-
-  """
-
-  @doc false
-  defmacro __using__(options) do
-    except = cond do
-      Keyword.get(options, :only_operators) ->
-        [bnot: 1, band: 2, bor: 2, bxor: 2, bsl: 2, bsr: 2]
-      Keyword.get(options, :skip_operators) ->
-        [~~~: 1, &&&: 2, |||: 2, ^^^: 2, <<<: 2, >>>: 2]
-      true ->
-        []
-    end
-
-    quote do
-      import Bitwise, except: unquote(except)
-    end
-  end
-
-  @doc """
-  Calculates the bitwise NOT of its argument.
-
-      iex> bnot(2)
-      -3
-      iex> bnot(2) &&& 3
-      1
-
-  """
-  defmacro bnot(expr) do
-    quote do: :erlang.bnot(unquote(expr))
-  end
-
-  @doc """
-  Prefix (unary) operator; calculates the bitwise NOT of its argument.
-
-      iex> ~~~2
-      -3
-      iex> ~~~2 &&& 3
-      1
-
-  """
-  defmacro ~~~expr do
-    quote do: :erlang.bnot(unquote(expr))
-  end
-
-  @doc """
-  Calculates the bitwise AND of its arguments.
-
-      iex> band(9, 3)
-      1
-
-  """
-  defmacro band(left, right) do
-    quote do: :erlang.band(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Infix operator; calculates the bitwise AND of its arguments.
-
-      iex> 9 &&& 3
-      1
-
-  """
-  defmacro left &&& right do
-    quote do: :erlang.band(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Calculates the bitwise OR of its arguments.
-
-      iex> bor(9, 3)
-      11
-
-  """
-  defmacro bor(left, right) do
-    quote do: :erlang.bor(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Infix operator; calculates the bitwise OR of its arguments.
-
-      iex> 9 ||| 3
-      11
-
-  """
-  defmacro left ||| right do
-    quote do: :erlang.bor(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Calculates the bitwise XOR of its arguments.
-
-      iex> bxor(9, 3)
-      10
-
-  """
-  defmacro bxor(left, right) do
-    quote do: :erlang.bxor(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Infix operator; calculates the bitwise XOR of its arguments.
-
-      iex> 9 ^^^ 3
-      10
-
-  """
-  defmacro left ^^^ right do
-    quote do: :erlang.bxor(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Calculates the result of an arithmetic left bitshift.
-
-      iex> bsl(1, 2)
-      4
-      iex> bsl(1, -2)
-      0
-      iex> bsl(-1, 2)
-      -4
-      iex> bsl(-1, -2)
-      -1
-
-  """
-  defmacro bsl(left, right) do
-    quote do: :erlang.bsl(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Infix operator; calculates the result of an arithmetic left bitshift.
-
-      iex> 1 <<< 2
-      4
-      iex> 1 <<< -2
-      0
-      iex> -1 <<< 2
-      -4
-      iex> -1 <<< -2
-      -1
-
-  """
-  defmacro left <<< right do
-    quote do: :erlang.bsl(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Calculates the result of an arithmetic right bitshift.
-
-      iex> bsr(1, 2)
-      0
-      iex> bsr(1, -2)
-      4
-      iex> bsr(-1, 2)
-      -1
-      iex> bsr(-1, -2)
-      -4
-
-  """
-  defmacro bsr(left, right) do
-    quote do: :erlang.bsr(unquote(left), unquote(right))
-  end
-
-  @doc """
-  Infix operator; calculates the result of an arithmetic right bitshift.
-
-      iex> 1 >>> 2
-      0
-      iex> 1 >>> -2
-      4
-      iex> -1 >>> 2
-      -1
-      iex> -1 >>> -2
-      -4
-
-  """
-  defmacro left >>> right do
-    quote do: :erlang.bsr(unquote(left), unquote(right))
-  end
-end

lib/elixir/lib/calendar.ex

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

lib/elixir/lib/calendar/date.ex

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

lib/elixir/lib/calendar/date_range.ex

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

lib/elixir/lib/calendar/datetime.ex

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

lib/elixir/lib/calendar/iso.ex

@@ -1,447 +0,0 @@
-defmodule Calendar.ISO do
-  @moduledoc """
-  A calendar implementation that follows to ISO8601.
-
-  This calendar implements the proleptic Gregorian calendar and
-  is therefore compatible with the calendar used in most countries
-  today. The proleptic means the Gregorian rules for leap years are
-  applied for all time, consequently the dates give different results
-  before the year 1583 from when the Gregorian calendar was adopted.
-
-  Note that while ISO8601 allows times and datetimes to specify
-  24:00:00 as the zero hour of the next day, this notation is not
-  supported by Elixir.
-  """
-
-  @behaviour Calendar
-
-  @unix_epoch 62167219200
-  @unix_start 1_000_000 * -@unix_epoch
-  @unix_end 1_000_000 * (315569519999 - @unix_epoch)
-  @unix_range_microseconds @unix_start..@unix_end
-
-  @type year :: 0..9999
-  @type month :: 1..12
-  @type day :: 1..31
-
-  @seconds_per_minute 60
-  @seconds_per_hour 60 * 60
-  @seconds_per_day 24 * 60 * 60 # Note that this does _not_ handle leap seconds.
-  @microseconds_per_second 1_000_000
-
-  @doc """
-  Returns the `t:Calendar.iso_days` format of the specified date.
-
-  ## Examples
-
-      iex> Calendar.ISO.naive_datetime_to_iso_days(0, 1, 1, 0, 0, 0, {0, 6})
-      {0, {0, 86400000000}}
-      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 12, 0, 0, {0, 6})
-      {730485, {43200000000, 86400000000}}
-      iex> Calendar.ISO.naive_datetime_to_iso_days(2000, 1, 1, 13, 0, 0, {0, 6})
-      {730485, {46800000000, 86400000000}}
-
-  """
-  @spec naive_datetime_to_iso_days(Calendar.year, Calendar.month, Calendar.day,
-                                   Calendar.hour, Calendar.minute, Calendar.second,
-                                   Calendar.microsecond) :: Calendar.iso_days
-  def naive_datetime_to_iso_days(year, month, day, hour, minute, second, microsecond) do
-    {date_to_iso_days_days(year, month, day),
-     time_to_day_fraction(hour, minute, second, microsecond)}
-  end
-
-  @doc """
-  Converts the `t:Calendar.iso_days` format to the datetime format specified by this calendar.
-
-  ## Examples
-
-      iex> Calendar.ISO.naive_datetime_from_iso_days({0, {0, 86400}})
-      {0, 1, 1, 0, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({730485, {0, 86400}})
-      {2000, 1, 1, 0, 0, 0, {0, 6}}
-      iex> Calendar.ISO.naive_datetime_from_iso_days({730485, {43200, 86400}})
-      {2000, 1, 1, 12, 0, 0, {0, 6}}
-
-  """
-  @spec naive_datetime_from_iso_days(Calendar.iso_days) ::
-        {Calendar.year, Calendar.month, Calendar.day,
-         Calendar.hour, Calendar.minute, Calendar.second, Calendar.microsecond}
-  def naive_datetime_from_iso_days({days, day_fraction}) do
-    {year, month, day} = date_from_iso_days_days(days)
-    {hour, minute, second, microsecond} = time_from_day_fraction(day_fraction)
-    {year, month, day, hour, minute, second, microsecond}
-  end
-
-  @doc """
-  Returns the normalized day fraction of the specified time.
-
-  ## Examples
-
-      iex> Calendar.ISO.time_to_day_fraction(0, 0, 0, {0, 6})
-      {0, 86400000000}
-      iex> Calendar.ISO.time_to_day_fraction(12, 34, 56, {123, 6})
-      {45296000123, 86400000000}
-
-  """
-  @spec time_to_day_fraction(Calendar.hour, Calendar.minute,
-                             Calendar.second, Calendar.microsecond) :: Calendar.day_fraction
-  def time_to_day_fraction(0, 0, 0, {0, _}) do
-    {0, 86400000000}
-  end
-  def time_to_day_fraction(hour, minute, second, {microsecond, _}) do
-    combined_seconds = hour * @seconds_per_hour + minute * @seconds_per_minute + second
-    {combined_seconds * @microseconds_per_second + microsecond, @seconds_per_day * @microseconds_per_second}
-  end
-
-  @doc """
-  Converts a day fraction to this Calendar's representation of time.
-
-  ## Examples
-
-      iex> Calendar.ISO.time_from_day_fraction({1,2})
-      {12, 0, 0, {0, 6}}
-      iex> Calendar.ISO.time_from_day_fraction({13,24})
-      {13, 0, 0, {0, 6}}
-
-  """
-  @spec time_from_day_fraction(Calendar.day_fraction) ::
-        {Calendar.hour, Calendar.minute, Calendar.second, Calendar.microsecond}
-  def time_from_day_fraction({parts_in_day, parts_per_day}) do
-    total_microseconds = div(parts_in_day * @seconds_per_day * @microseconds_per_second, parts_per_day)
-    {hours, rest_microseconds1} = div_mod(total_microseconds, @seconds_per_hour * @microseconds_per_second)
-    {minutes, rest_microseconds2} = div_mod(rest_microseconds1, @seconds_per_minute * @microseconds_per_second)
-    {seconds, microseconds} = div_mod(rest_microseconds2, @microseconds_per_second)
-    {hours, minutes, seconds, {microseconds, 6}}
-  end
-
-  # Converts year, month, day to count of days since 0000-01-01.
-  @doc false
-  def date_to_iso_days_days(0, 1, 1) do
-    0
-  end
-  def date_to_iso_days_days(1970, 1, 1) do
-    719528
-  end
-  def date_to_iso_days_days(year, month, day) do
-    :calendar.date_to_gregorian_days(year, month, day)
-  end
-
-  # Converts count of days since 0000-01-01 to {year, month, day} tuple.
-  @doc false
-  def date_from_iso_days_days(days) do
-    :calendar.gregorian_days_to_date(days)
-  end
-
-  defp div_mod(int1, int2) do
-    div = div(int1, int2)
-    mod = int1 - (div * int2)
-    {div, mod}
-  end
-
-  @doc """
-  Returns how many days there are in the given year-month.
-
-  ## Examples
-
-      iex> Calendar.ISO.days_in_month(1900, 1)
-      31
-      iex> Calendar.ISO.days_in_month(1900, 2)
-      28
-      iex> Calendar.ISO.days_in_month(2000, 2)
-      29
-      iex> Calendar.ISO.days_in_month(2001, 2)
-      28
-      iex> Calendar.ISO.days_in_month(2004, 2)
-      29
-      iex> Calendar.ISO.days_in_month(2004, 4)
-      30
-
-  """
-  @spec days_in_month(year, month) :: 28..31
-  def days_in_month(year, month)
-
-  def days_in_month(year, 2) do
-    if leap_year?(year), do: 29, else: 28
-  end
-  def days_in_month(_, month) when month in [4, 6, 9, 11], do: 30
-  def days_in_month(_, month) when month in 1..12, do: 31
-
-  @doc """
-  Returns if the given year is a leap year.
-
-  ## Examples
-
-      iex> Calendar.ISO.leap_year?(2000)
-      true
-      iex> Calendar.ISO.leap_year?(2001)
-      false
-      iex> Calendar.ISO.leap_year?(2004)
-      true
-      iex> Calendar.ISO.leap_year?(1900)
-      false
-
-  """
-  @spec leap_year?(year) :: boolean()
-  def leap_year?(year) when is_integer(year) and year >= 0 do
-    rem(year, 4) === 0 and (rem(year, 100) > 0 or rem(year, 400) === 0)
-  end
-
-  @doc """
-  Calculates the day of the week from the given `year`, `month`, and `day`.
-
-  It is an integer from 1 to 7, where 1 is Monday and 7 is Sunday.
-
-  ## Examples
-
-      iex> Calendar.ISO.day_of_week(2016, 10, 31)
-      1
-      iex> Calendar.ISO.day_of_week(2016, 11, 01)
-      2
-      iex> Calendar.ISO.day_of_week(2016, 11, 02)
-      3
-      iex> Calendar.ISO.day_of_week(2016, 11, 03)
-      4
-      iex> Calendar.ISO.day_of_week(2016, 11, 04)
-      5
-      iex> Calendar.ISO.day_of_week(2016, 11, 05)
-      6
-      iex> Calendar.ISO.day_of_week(2016, 11, 06)
-      7
-  """
-  @spec day_of_week(year, month, day) :: 1..7
-  def day_of_week(year, month, day)
-      when is_integer(year) and is_integer(month) and is_integer(day) do
-    :calendar.day_of_the_week(year, month, day)
-  end
-
-  @doc """
-  Converts the given time into a string.
-  """
-  def time_to_string(hour, minute, second, microsecond, format \\ :extended)
-
-  def time_to_string(hour, minute, second, {_, 0}, format) do
-    time_to_string_format(hour, minute, second, format)
-  end
-
-  def time_to_string(hour, minute, second, {microsecond, precision}, format) do
-    time_to_string_format(hour, minute, second, format) <>
-      "." <> (microsecond |> zero_pad(6) |> binary_part(0, precision))
-  end
-
-  defp time_to_string_format(hour, minute, second, :extended) do
-    zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2) <> ":" <> zero_pad(second, 2)
-  end
-
-  defp time_to_string_format(hour, minute, second, :basic) do
-    zero_pad(hour, 2) <> zero_pad(minute, 2) <> zero_pad(second, 2)
-  end
-
-  @doc """
-  Converts the given date into a string.
-  """
-  def date_to_string(year, month, day) do
-    zero_pad(year, 4) <> "-" <> zero_pad(month, 2) <> "-" <> zero_pad(day, 2)
-  end
-
-  defp date_to_string(year, month, day, :extended), do: date_to_string(year, month, day)
-  defp date_to_string(year, month, day, :basic) do
-    zero_pad(year, 4) <> zero_pad(month, 2) <> zero_pad(day, 2)
-  end
-
-  @doc """
-  Converts the datetime (without time zone) into a string.
-  """
-  def naive_datetime_to_string(year, month, day, hour, minute, second, microsecond) do
-    date_to_string(year, month, day) <> " " <> time_to_string(hour, minute, second, microsecond)
-  end
-
-  @doc """
-  Convers the datetime (with time zone) into a string.
-  """
-  def datetime_to_string(year, month, day, hour, minute, second, microsecond,
-                         time_zone, zone_abbr, utc_offset, std_offset) do
-    date_to_string(year, month, day) <> " " <>
-      time_to_string(hour, minute, second, microsecond) <>
-      offset_to_string(utc_offset, std_offset, time_zone) <>
-      zone_to_string(utc_offset, std_offset, zone_abbr, time_zone)
-  end
-
-  def valid_date?(year, month, day) do
-    year <= 9999 and :calendar.valid_date(year, month, day)
-  end
-
-  def valid_time?(hour, minute, second, {microsecond, precision}) do
-    hour in 0..23 and minute in 0..59 and second in 0..60 and
-      microsecond in 0..999_999 and precision in 0..6
-  end
-
-  def day_rollover_relative_to_midnight_utc() do
-    {0, 1}
-  end
-
-  defp offset_to_string(utc, std, zone, format \\ :extended)
-  defp offset_to_string(0, 0, "Etc/UTC", _format), do: "Z"
-  defp offset_to_string(utc, std, _zone, format) do
-    total = utc + std
-    second = abs(total)
-    minute = second |> rem(3600) |> div(60)
-    hour = div(second, 3600)
-    format_offset(total, hour, minute, format)
-  end
-
-  defp format_offset(total, hour, minute, :extended) do
-    sign(total) <> zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2)
-  end
-
-  defp format_offset(total, hour, minute, :basic) do
-    sign(total) <> zero_pad(hour, 2) <> zero_pad(minute, 2)
-  end
-
-  defp zone_to_string(0, 0, _abbr, "Etc/UTC"), do: ""
-  defp zone_to_string(_, _, abbr, zone), do: " " <> abbr <> " " <> zone
-
-  defp sign(total) when total < 0, do: "-"
-  defp sign(_), do: "+"
-
-  defp zero_pad(val, count) do
-    num = Integer.to_string(val)
-    :binary.copy("0", count - byte_size(num)) <> num
-  end
-
-  ## Helpers
-
-  @doc false
-  def from_unix(integer, unit) when is_integer(integer) do
-    total = System.convert_time_unit(integer, unit, :microsecond)
-    if total in @unix_range_microseconds do
-      microsecond = rem(total, 1_000_000)
-      precision = precision_for_unit(unit)
-      {date, time} = :calendar.gregorian_seconds_to_datetime(@unix_epoch + div(total, 1_000_000))
-      {:ok, date, time, {microsecond, precision}}
-    else
-      {:error, :invalid_unix_time}
-    end
-  end
-
-  defp precision_for_unit(unit) do
-    subsecond = div System.convert_time_unit(1, :second, unit), 10
-    precision_for_unit(subsecond, 0)
-  end
-
-  defp precision_for_unit(0, precision),
-    do: precision
-  defp precision_for_unit(_, 6),
-    do: 6
-  defp precision_for_unit(number, precision),
-    do: precision_for_unit(div(number, 10), precision + 1)
-
-  @doc false
-  def date_to_iso8601(year, month, day, format \\ :extended) do
-    date_to_string(year, month, day, format)
-  end
-
-  @doc false
-  def time_to_iso8601(hour, minute, second, microsecond, format \\ :extended) do
-    time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  @doc false
-  def naive_datetime_to_iso8601(year, month, day, hour, minute, second, microsecond, format \\ :extended) do
-    date_to_string(year, month, day, format) <> "T" <> time_to_string(hour, minute, second, microsecond, format)
-  end
-
-  @doc false
-  def datetime_to_iso8601(year, month, day, hour, minute, second, microsecond,
-                          time_zone, _zone_abbr, utc_offset, std_offset, format \\ :extended) do
-    date_to_string(year, month, day, format) <> "T" <>
-      time_to_string(hour, minute, second, microsecond, format) <>
-      offset_to_string(utc_offset, std_offset, time_zone, format)
-  end
-
-  @doc false
-  def parse_microsecond("." <> rest) do
-    case parse_microsecond(rest, 0, "") do
-      {"", 0, _} ->
-        :error
-      {microsecond, precision, rest} when precision in 1..6 ->
-        pad = String.duplicate("0", 6 - byte_size(microsecond))
-        {{String.to_integer(microsecond <> pad), precision}, rest}
-      {microsecond, _precision, rest} ->
-        {{String.to_integer(binary_part(microsecond, 0, 6)), 6}, rest}
-    end
-  end
-
-  def parse_microsecond("," <> rest) do
-    parse_microsecond("." <> rest)
-  end
-
-  def parse_microsecond(rest) do
-    {{0, 0}, rest}
-  end
-
-  defp parse_microsecond(<<head, tail::binary>>, precision, acc) when head in ?0..?9,
-    do: parse_microsecond(tail, precision + 1, <<acc::binary, head>>)
-  defp parse_microsecond(rest, precision, acc),
-    do: {acc, precision, rest}
-
-  @doc false
-  def parse_offset(""),
-    do: {nil, ""}
-  def parse_offset("Z"),
-    do: {0, ""}
-  def parse_offset("-00:00"),
-    do: :error
-  def parse_offset(<<?+, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
-    do: parse_offset(1, hour, min, rest)
-  def parse_offset(<<?-, hour::2-bytes, ?:, min::2-bytes, rest::binary>>),
-    do: parse_offset(-1, hour, min, rest)
-  def parse_offset(<<?+, hour::2-bytes, min::2-bytes, rest::binary>>),
-    do: parse_offset(1, hour, min, rest)
-  def parse_offset(<<?-, hour::2-bytes, min::2-bytes, rest::binary>>),
-    do: parse_offset(-1, hour, min, rest)
-  def parse_offset(<<?+, hour::2-bytes, rest::binary>>),
-    do: parse_offset(1, hour, "00", rest)
-  def parse_offset(<<?-, hour::2-bytes, rest::binary>>),
-    do: parse_offset(-1, hour, "00", rest)
-  def parse_offset(_),
-    do: :error
-
-  defp parse_offset(sign, hour, min, rest) do
-    with {hour, ""} when hour < 24 <- Integer.parse(hour),
-         {min, ""} when min < 60 <- Integer.parse(min) do
-      {((hour * 60) + min) * 60 * sign, rest}
-    else
-      _ -> :error
-    end
-  end
-
-  @doc false
-  def iso_days_to_unit({days, {parts, ppd}}, unit) do
-    day_microseconds = days * @seconds_per_day * @microseconds_per_second
-    microseconds = div(parts * @seconds_per_day * @microseconds_per_second, ppd)
-    System.convert_time_unit(day_microseconds + microseconds, :microsecond, unit)
-  end
-
-  @doc false
-  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, ppd) do
-    normalize_iso_days(days, parts + add, ppd)
-  end
-  def add_day_fraction_to_iso_days({days, {parts, ppd}}, add, add_ppd) do
-    parts = parts * add_ppd
-    add = add * ppd
-    gcd = Integer.gcd(ppd, add_ppd)
-    result_parts = div(parts + add, gcd)
-    result_ppd = div(ppd * add_ppd, gcd)
-    normalize_iso_days(days, result_parts, result_ppd)
-  end
-
-  defp normalize_iso_days(days, parts, ppd) do
-    days_offset = div(parts, ppd)
-    parts = rem(parts, ppd)
-    if parts < 0 do
-      {days + days_offset - 1, {parts + ppd, ppd}}
-    else
-      {days + days_offset, {parts, ppd}}
-    end
-  end
-end

lib/elixir/lib/calendar/naive_datetime.ex

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

lib/elixir/lib/calendar/time.ex

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

lib/elixir/lib/code.ex

@@ -1,694 +0,0 @@
-defmodule Code do
-  @moduledoc """
-  Utilities for managing code compilation, code evaluation and code loading.
-
-  This module complements Erlang's [`:code` module](http://www.erlang.org/doc/man/code.html)
-  to add behaviour which is specific to Elixir. Almost all of the functions in this module
-  have global side effects on the behaviour of Elixir.
-  """
-
-  @doc """
-  Lists all loaded files.
-
-  ## Examples
-
-      Code.require_file("../eex/test/eex_test.exs")
-      List.first(Code.loaded_files) =~ "eex_test.exs" #=> true
-
-  """
-  def loaded_files do
-    :elixir_code_server.call :loaded
-  end
-
-  @doc """
-  Removes files from the loaded files list.
-
-  The modules defined in the file are not removed;
-  calling this function only removes them from the list,
-  allowing them to be required again.
-
-  ## Examples
-
-      # Load EEx test code, unload file, check for functions still available
-      Code.load_file("../eex/test/eex_test.exs")
-      Code.unload_files(Code.loaded_files)
-      function_exported?(EExTest.Compiled, :before_compile, 0) #=> true
-
-  """
-  def unload_files(files) do
-    :elixir_code_server.cast {:unload_files, files}
-  end
-
-  @doc """
-  Appends a path to the end of the Erlang VM code path list.
-
-  This is the list of directories the Erlang VM uses for
-  finding module code.
-
-  The path is expanded with `Path.expand/1` before being appended.
-  If this path does not exist, an error is returned.
-
-  ## Examples
-
-      Code.append_path(".") #=> true
-
-      Code.append_path("/does_not_exist") #=> {:error, :bad_directory}
-
-  """
-  def append_path(path) do
-    :code.add_pathz(to_charlist(Path.expand path))
-  end
-
-  @doc """
-  Prepends a path to the beginning of the Erlang VM code path list.
-
-  This is the list of directories the Erlang VM uses for finding
-  module code.
-
-  The path is expanded with `Path.expand/1` before being prepended.
-  If this path does not exist, an error is returned.
-
-  ## Examples
-
-      Code.prepend_path(".") #=> true
-
-      Code.prepend_path("/does_not_exist") #=> {:error, :bad_directory}
-
-  """
-  def prepend_path(path) do
-    :code.add_patha(to_charlist(Path.expand path))
-  end
-
-  @doc """
-  Deletes a path from the Erlang VM code path list. This is the list of
-  directories the Erlang VM uses for finding module code.
-
-  The path is expanded with `Path.expand/1` before being deleted. If the
-  path does not exist it returns `false`.
-
-  ## Examples
-
-      Code.prepend_path(".")
-      Code.delete_path(".") #=> true
-
-      Code.delete_path("/does_not_exist") #=> false
-
-  """
-  def delete_path(path) do
-    :code.del_path(to_charlist(Path.expand path))
-  end
-
-  @doc """
-  Evaluates the contents given by `string`.
-
-  The `binding` argument is a keyword list of variable bindings.
-  The `opts` argument is a keyword list of environment options.
-
-  **Warning**: `string` can be any Elixir code and will be executed with
-  the same privileges as the Erlang VM: this means that such code could
-  compromise the machine (for example by executing system commands).
-  Don't use `eval_string/3` with untrusted input (such as strings coming
-  from the network).
-
-  ## Options
-
-  Options can be:
-
-    * `:file` - the file to be considered in the evaluation
-    * `:line` - the line on which the script starts
-
-  Additionally, the following scope values can be configured:
-
-    * `:aliases` - a list of tuples with the alias and its target
-
-    * `:requires` - a list of modules required
-
-    * `:functions` - a list of tuples where the first element is a module
-      and the second a list of imported function names and arity; the list
-      of function names and arity must be sorted
-
-    * `:macros` - a list of tuples where the first element is a module
-      and the second a list of imported macro names and arity; the list
-      of function names and arity must be sorted
-
-  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`,
-  etc.
-
-  Returns a tuple of the form `{value, binding}`,
-  where `value` is the value returned from evaluating `string`.
-  If an error occurs while evaluating `string` an exception will be raised.
-
-  `binding` is a keyword list with the value of all variable bindings
-  after evaluating `string`. The binding key is usually an atom, but it
-  may be a tuple for variables defined in a different context.
-
-  ## Examples
-
-      iex> Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      {3, [a: 1, b: 2]}
-
-      iex> Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2, c: 3]}
-
-      iex> Code.eval_string("a = a + b", [a: 1, b: 2])
-      {3, [a: 3, b: 2]}
-
-  For convenience, you can pass `__ENV__/0` as the `opts` argument and
-  all imports, requires and aliases defined in the current environment
-  will be automatically carried over:
-
-      iex> Code.eval_string("a + b", [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2]}
-
-  """
-  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}
-  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}
-  end
-
-  @doc """
-  Evaluates the quoted contents.
-
-  **Warning**: Calling this function inside a macro is considered bad
-  practice as it will attempt to evaluate runtime values at compile time.
-  Macro arguments are typically transformed by unquoting them into the
-  returned quoted expressions (instead of evaluated).
-
-  See `eval_string/3` for a description of bindings and options.
-
-  ## Examples
-
-      iex> contents = quote(do: var!(a) + var!(b))
-      iex> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      {3, [a: 1, b: 2]}
-
-  For convenience, you can pass `__ENV__/0` as the `opts` argument and
-  all options will be automatically extracted from the current environment:
-
-      iex> contents = quote(do: var!(a) + var!(b))
-      iex> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
-      {3, [a: 1, b: 2]}
-
-  """
-  def eval_quoted(quoted, binding \\ [], opts \\ [])
-
-  def eval_quoted(quoted, binding, %Macro.Env{} = env) do
-    {value, binding, _env, _scope} = :elixir.eval_quoted quoted, binding, Map.to_list(env)
-    {value, binding}
-  end
-
-  def eval_quoted(quoted, binding, opts) when is_list(opts) do
-    validate_eval_opts(opts)
-    {value, binding, _env, _scope} = :elixir.eval_quoted quoted, binding, opts
-    {value, binding}
-  end
-
-  defp validate_eval_opts(opts) do
-    if f = opts[:functions], do: validate_imports(:functions, f)
-    if m = opts[:macros],    do: validate_imports(:macros, m)
-    if a = opts[:aliases],   do: validate_aliases(:aliases, a)
-    if r = opts[:requires],  do: validate_requires(:requires, r)
-  end
-
-  defp validate_requires(kind, requires) do
-    valid = is_list(requires) and Enum.all?(requires, &is_atom(&1))
-
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [module]"
-    end
-  end
-
-  defp validate_aliases(kind, aliases) do
-    valid = is_list(aliases) and Enum.all?(aliases, fn {k, v} ->
-      is_atom(k) and is_atom(v)
-    end)
-
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [{module, module}]"
-    end
-  end
-
-  defp validate_imports(kind, imports) do
-    valid = is_list(imports) and Enum.all?(imports, fn {k, v} ->
-      is_atom(k) and is_list(v) and Enum.all?(v, fn {name, arity} ->
-        is_atom(name) and is_integer(arity)
-      end)
-    end)
-
-    unless valid do
-      raise ArgumentError, "expected :#{kind} option given to eval in the format: [{module, [{name, arity}]}]"
-    end
-  end
-
-  @doc """
-  Converts the given string to its quoted form.
-
-  Returns `{:ok, quoted_form}`
-  if it succeeds, `{:error, {line, error, token}}` otherwise.
-
-  ## Options
-
-    * `:file` - the filename to be used in stacktraces
-      and the file reported in the `__ENV__/0` macro
-
-    * `:line` - the line reported in the `__ENV__/0` macro
-
-    * `:existing_atoms_only` - when `true`, raises an error
-      when non-existing atoms are found by the tokenizer
-
-  ## Macro.to_string/2
-
-  The opposite of converting a string to its quoted form is
-  `Macro.to_string/2`, which converts a quoted form to a string/binary
-  representation.
-  """
-  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)
-  end
-
-  @doc """
-  Converts the given string to its quoted form.
-
-  It returns the ast if it succeeds,
-  raises an exception otherwise. The exception is a `TokenMissingError`
-  in case a token is missing (usually because the expression is incomplete),
-  `SyntaxError` otherwise.
-
-  Check `string_to_quoted/2` for options information.
-  """
-  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)
-  end
-
-  @doc """
-  Evals the given file.
-
-  Accepts `relative_to` as an argument to tell where the file is located.
-
-  While `load_file` loads a file and returns the loaded modules and their
-  byte code, `eval_file` simply evaluates the file contents and returns the
-  evaluation result and its bindings.
-  """
-  def eval_file(file, relative_to \\ nil) do
-    file = find_file(file, relative_to)
-    eval_string File.read!(file), [], [file: file, line: 1]
-  end
-
-  @doc """
-  Loads the given file.
-
-  Accepts `relative_to` as an argument to tell where the file is located.
-  If the file was already required/loaded, loads it again.
-
-  It returns a list of tuples `{ModuleName, <<byte_code>>}`, one tuple for
-  each module defined in the file.
-
-  Notice that if `load_file` is invoked by different processes concurrently,
-  the target file will be loaded concurrently many times. Check `require_file/2`
-  if you don't want a file to be loaded concurrently.
-
-  ## Examples
-
-      Code.load_file("eex_test.exs", "../eex/test") |> List.first
-      #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
-
-  """
-  def load_file(file, relative_to \\ nil) when is_binary(file) do
-    file = find_file(file, relative_to)
-    :elixir_code_server.call {:acquire, file}
-    loaded = :elixir_compiler.file file
-    :elixir_code_server.cast {:loaded, file}
-    loaded
-  end
-
-  @doc """
-  Requires the given `file`.
-
-  Accepts `relative_to` as an argument to tell where the file is located.
-  The return value is the same as that of `load_file/2`. If the file was already
-  required/loaded, `require_file` doesn't do anything and returns `nil`.
-
-  Notice that if `require_file` is invoked by different processes concurrently,
-  the first process to invoke `require_file` acquires a lock and the remaining
-  ones will block until the file is available. I.e., if `require_file` is called
-  N times with a given file, it will be loaded only once. The first process to
-  call `require_file` will get the list of loaded modules, others will get `nil`.
-
-  Check `load_file/2` if you want a file to be loaded multiple times. See also
-  `unload_files/1`
-
-  ## Examples
-
-  If the code is already loaded, it returns `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
-      #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}
-
-  """
-  def require_file(file, relative_to \\ nil) when is_binary(file) do
-    file = find_file(file, relative_to)
-
-    case :elixir_code_server.call({:acquire, file}) do
-      :loaded  ->
-        nil
-      {:queued, ref}  ->
-        receive do {:elixir_code_server, ^ref, :loaded} -> nil end
-      :proceed ->
-        loaded = :elixir_compiler.file file
-        :elixir_code_server.cast {:loaded, file}
-        loaded
-    end
-  end
-
-  @doc """
-  Gets the compilation options from the code server.
-
-  Check `compiler_options/1` for more information.
-
-  ## Examples
-
-      Code.compiler_options
-      #=> %{debug_info: true, docs: true,
-            warnings_as_errors: false, ignore_module_conflict: false}
-
-  """
-  def compiler_options do
-    :elixir_config.get :compiler_options
-  end
-
-  @doc """
-  Returns a list with the available compiler options.
-
-  See `Code.compiler_options/1` for more info.
-
-  ## Examples
-
-      iex> Code.available_compiler_options
-      [:docs, :debug_info, :ignore_module_conflict, :relative_paths, :warnings_as_errors]
-
-  """
-  def available_compiler_options do
-    [:docs, :debug_info, :ignore_module_conflict, :relative_paths, :warnings_as_errors]
-  end
-
-  @doc """
-  Sets compilation options.
-
-  These options are global since they are stored by Elixir's Code Server.
-
-  Available options are:
-
-    * `:docs` - when `true`, retain documentation in the compiled module,
-      `true` by default
-
-    * `:debug_info` - when `true`, retain debug information in the compiled
-      module; this allows a developer to reconstruct the original source
-      code, `false` by default
-
-    * `:ignore_module_conflict` - when `true`, override modules that were
-      already defined without raising errors, `false` by default
-
-    * `:relative_paths` - when `true`, use relative paths in quoted nodes,
-      warnings and errors generated by the compiler, `true` by default.
-      Note disabling this option won't affect runtime warnings and errors.
-
-    * `:warnings_as_errors` - causes compilation to fail when warnings are
-      generated
-
-  It returns the new list of compiler options.
-
-  ## Examples
-
-      Code.compiler_options(debug_info: true)
-      #=> %{debug_info: true, docs: true,
-            warnings_as_errors: false, ignore_module_conflict: false}
-
-  """
-  def compiler_options(opts) do
-    available = available_compiler_options()
-
-    Enum.each(opts, fn({key, value}) ->
-      cond do
-        key not in available ->
-          raise "unknown compiler option: #{inspect(key)}"
-        not is_boolean(value) ->
-          raise "compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}"
-        true ->
-          :ok
-      end
-    end)
-
-    :elixir_config.update :compiler_options, &Enum.into(opts, &1)
-  end
-
-  @doc """
-  Compiles the given string.
-
-  Returns a list of tuples where the first element is the module name
-  and the second one is its byte code (as a binary).
-
-  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
-  end
-
-  @doc """
-  Compiles the quoted expression.
-
-  Returns a list of tuples where the first element is the module name and
-  the second one is its byte code (as a binary).
-  """
-  def compile_quoted(quoted, file \\ "nofile") when is_binary(file) do
-    :elixir_compiler.quoted quoted, file
-  end
-
-  @doc """
-  Ensures the given module is loaded.
-
-  If the module is already loaded, this works as no-op. If the module
-  was not yet loaded, it tries to load it.
-
-  If it succeeds loading the module, it returns `{:module, module}`.
-  If not, returns `{:error, reason}` with the error reason.
-
-  ## Code loading on the Erlang VM
-
-  Erlang has two modes to load code: interactive and embedded.
-
-  By default, the Erlang VM runs in interactive mode, where modules
-  are loaded as needed. In embedded mode the opposite happens, as all
-  modules need to be loaded upfront or explicitly.
-
-  Therefore, this function is used to check if a module is loaded
-  before using it and allows one to react accordingly. For example, the `URI`
-  module uses this function to check if a specific parser exists for a given
-  URI scheme.
-
-  ## `ensure_compiled/1`
-
-  Elixir also contains an `ensure_compiled/1` function that is a
-  superset of `ensure_loaded/1`.
-
-  Since Elixir's compilation happens in parallel, in some situations
-  you may need to use a module that was not yet compiled, therefore
-  it can't even be loaded.
-
-  When invoked, `ensure_compiled/1` halts the compilation of the caller
-  until the module given to `ensure_compiled/1` becomes available or
-  all files for the current project have been compiled. If compilation
-  finishes and the module is not available, an error tuple is returned.
-
-  `ensure_compiled/1` does not apply to dependencies, as dependencies
-  must be compiled upfront.
-
-  In most cases, `ensure_loaded/1` is enough. `ensure_compiled/1`
-  must be used in rare cases, usually involving macros that need to
-  invoke a module for callback information.
-
-  ## Examples
-
-      iex> Code.ensure_loaded(Atom)
-      {:module, Atom}
-
-      iex> Code.ensure_loaded(DoesNotExist)
-      {:error, :nofile}
-
-  """
-  @spec ensure_loaded(module) ::
-        {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}
-  def ensure_loaded(module) when is_atom(module) do
-    :code.ensure_loaded(module)
-  end
-
-  @doc """
-  Ensures the given module is loaded.
-
-  Similar to `ensure_loaded/1`, but returns `true` if the module
-  is already loaded or was successfully loaded. Returns `false`
-  otherwise.
-
-  ## Examples
-
-      iex> Code.ensure_loaded?(Atom)
-      true
-
-  """
-  def ensure_loaded?(module) when is_atom(module) do
-    match?({:module, ^module}, ensure_loaded(module))
-  end
-
-  @doc """
-  Ensures the given module is compiled and loaded.
-
-  If the module is already loaded, it works as no-op. If the module was
-  not loaded yet, it checks if it needs to be compiled first and then
-  tries to load it.
-
-  If it succeeds loading the module, it returns `{:module, module}`.
-  If not, returns `{:error, reason}` with the error reason.
-
-  Check `ensure_loaded/1` for more information on module loading
-  and when to use `ensure_loaded/1` or `ensure_compiled/1`.
-  """
-  @spec ensure_compiled(module) ::
-        {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure}
-  def ensure_compiled(module) when is_atom(module) do
-    case :code.ensure_loaded(module) do
-      {:error, :nofile} = error ->
-        if is_pid(:erlang.get(:elixir_compiler_pid)) and
-           Kernel.ErrorHandler.ensure_compiled(module, :module) do
-          {:module, module}
-        else
-          error
-        end
-      other -> other
-    end
-  end
-
-  @doc """
-  Ensures the given module is compiled and loaded.
-
-  Similar to `ensure_compiled/1`, but returns `true` if the module
-  is already loaded or was successfully loaded and compiled.
-  Returns `false` otherwise.
-  """
-  @spec ensure_compiled?(module) :: boolean
-  def ensure_compiled?(module) when is_atom(module) do
-    match?({:module, ^module}, ensure_compiled(module))
-  end
-
-  @doc ~S"""
-  Returns the docs for the given module.
-
-  When given a module name, it finds its BEAM code and reads the docs from it.
-
-  When given a path to a .beam file, it will load the docs directly from that
-  file.
-
-  The return value depends on the `kind` value:
-
-    * `:docs` - list of all docstrings attached to functions and macros
-      using the `@doc` attribute
-
-    * `:moduledoc` - tuple `{<line>, <doc>}` where `line` is the line on
-      which module definition starts and `doc` is the string
-      attached to the module using the `@moduledoc` attribute
-
-    * `:callback_docs` - list of all docstrings attached to
-      `@callbacks` using the `@doc` attribute
-
-    * `:type_docs` - list of all docstrings attached to
-      `@type` callbacks using the `@typedoc` attribute
-
-    * `:all` - a keyword list with `:docs` and `:moduledoc`, `:callback_docs`,
-      and `:type_docs`.
-
-  If the module cannot be found, it returns `nil`.
-
-  ## Examples
-
-      # Get the module documentation
-      iex> {_line, text} = Code.get_docs(Atom, :moduledoc)
-      iex> String.split(text, "\n") |> Enum.at(0)
-      "Convenience functions for working with atoms."
-
-      # Module doesn't exist
-      iex> Code.get_docs(ModuleNotGood, :all)
-      nil
-
-  """
-  @doc_kinds [:docs, :moduledoc, :callback_docs, :type_docs, :all]
-
-  def get_docs(module, kind) when is_atom(module) and kind in @doc_kinds do
-    case :code.get_object_code(module) do
-      {_module, bin, _beam_path} ->
-        do_get_docs(bin, kind)
-
-      :error -> nil
-    end
-  end
-
-  def get_docs(binpath, kind) when is_binary(binpath) and kind in @doc_kinds do
-    do_get_docs(String.to_charlist(binpath), kind)
-  end
-
-  @docs_chunk 'ExDc'
-
-  defp do_get_docs(bin_or_path, kind) do
-    case :beam_lib.chunks(bin_or_path, [@docs_chunk]) do
-      {:ok, {_module, [{@docs_chunk, bin}]}} ->
-        lookup_docs(:erlang.binary_to_term(bin), kind)
-
-      {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} -> nil
-    end
-  end
-
-  defp lookup_docs({:elixir_docs_v1, docs}, kind),
-    do: do_lookup_docs(docs, kind)
-
-  # unsupported chunk version
-  defp lookup_docs(_, _), do: nil
-
-  defp do_lookup_docs(docs, :all), do: docs
-  defp do_lookup_docs(docs, kind),
-    do: Keyword.get(docs, kind)
-
-  ## Helpers
-
-  # Finds the file given the relative_to path.
-  #
-  # If the file is found, returns its path in binary, fails otherwise.
-  defp find_file(file, relative_to) do
-    file = if relative_to do
-      Path.expand(file, relative_to)
-    else
-      Path.expand(file)
-    end
-
-    if File.regular?(file) do
-      file
-    else
-      raise Code.LoadError, file: file
-    end
-  end
-end

lib/elixir/lib/collectable.ex

@@ -1,108 +0,0 @@
-defprotocol Collectable do
-  @moduledoc """
-  A protocol to traverse data structures.
-
-  The `Enum.into/2` function uses this protocol to insert an
-  enumerable into a collection:
-
-      iex> Enum.into([a: 1, b: 2], %{})
-      %{a: 1, b: 2}
-
-  ## Why Collectable?
-
-  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.
-
-  This design is intentional. `Enumerable` was designed to support infinite
-  collections, resources and other structures with fixed shape. For example,
-  it doesn't make sense to insert values into a range, as it has a fixed
-  shape where just the range limits are stored.
-
-  The `Collectable` module was designed to fill the gap left by the
-  `Enumerable` protocol. `into/1` can be seen as the opposite of
-  `Enumerable.reduce/3`. If `Enumerable` is about taking values out,
-  `Collectable.into/1` is about collecting those values into a structure.
-
-  ## Examples
-
-  To show how to manually use the `Collectable` protocol, let's play with its
-  implementation for `MapSet`.
-
-      iex> {initial_acc, collector_fun} = Collectable.into(MapSet.new())
-      iex> updated_acc = Enum.reduce([1, 2, 3], initial_acc, fn elem, acc ->
-      ...>   collector_fun.(acc, {:cont, elem})
-      ...> end)
-      iex> collector_fun.(updated_acc, :done)
-      #MapSet<[1, 2, 3]>
-
-  To show how the protocol can be implemented, we can take again a look at the
-  implementation for `MapSet`. In this implementation "collecting" elements
-  simply means inserting them in the set through `MapSet.put/2`.
-
-      defimpl Collectable do
-        def into(original) do
-          collector_fun = fn
-            set, {:cont, elem} -> MapSet.put(set, elem)
-            set, :done -> set
-            _set, :halt -> :ok
-          end
-
-          {original, collector_fun}
-        end
-      end
-
-  """
-
-  @type command :: {:cont, term} | :done | :halt
-
-  @doc """
-  Returns an initial accumulator and a "collector" function.
-
-  The returned function receives a term and a command and injects the term into
-  the collectable on every `{:cont, term}` command.
-
-  `:done` is passed as a command when no further values will be injected. This
-  is useful when there's a need to close resources or normalizing values. A
-  collectable must be returned when the command is `:done`.
-
-  If injection is suddenly interrupted, `:halt` is passed and the function
-  can return any value as it won't be used.
-
-  For examples on how to use the `Collectable` protocol and `into/1` see the
-  module documentation.
-  """
-  @spec into(t) :: {term, (term, command -> t | term)}
-  def into(collectable)
-end
-
-defimpl Collectable, for: List do
-  def into(original) do
-    {[], fn
-      list, {:cont, x} -> [x | list]
-      list, :done -> original ++ :lists.reverse(list)
-      _, :halt -> :ok
-    end}
-  end
-end
-
-defimpl Collectable, for: BitString do
-  def into(original) do
-    {original, fn
-      acc, {:cont, x} when is_bitstring(x) -> [acc | x]
-      acc, :done -> IO.iodata_to_binary(acc)
-      _, :halt -> :ok
-    end}
-  end
-end
-
-defimpl Collectable, for: Map do
-  def into(original) do
-    {original, fn
-      map, {:cont, {k, v}} -> :maps.put(k, v, map)
-      map, :done -> map
-      _, :halt -> :ok
-    end}
-  end
-end

lib/elixir/lib/dict.ex

@@ -1,367 +0,0 @@
-defmodule Dict do
-  @moduledoc ~S"""
-  WARNING: this module is deprecated.
-
-  If you need a general dictionary, use the `Map` module.
-  If you need to manipulate keyword lists, use `Keyword`.
-
-  To convert maps into keywords and vice-versa, use the
-  `new` function in the respective modules.
-  """
-
-  @type key :: any
-  @type value :: any
-  @type t :: list | map
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-
-  defmacro __using__(_) do
-    # Use this import to guarantee proper code expansion
-    import Kernel, except: [size: 1]
-
-    quote do
-      def get(dict, key, default \\ nil) do
-        case fetch(dict, key) do
-          {:ok, value} -> value
-          :error -> default
-        end
-      end
-
-      def get_lazy(dict, key, fun) when is_function(fun, 0) do
-        case fetch(dict, key) do
-          {:ok, value} -> value
-          :error -> fun.()
-        end
-      end
-
-      def get_and_update(dict, key, fun) do
-        current_value = get(dict, key)
-        {get, new_value} = fun.(current_value)
-        {get, put(dict, key, new_value)}
-      end
-
-      def fetch!(dict, key) do
-        case fetch(dict, key) do
-          {:ok, value} -> value
-          :error -> raise KeyError, key: key, term: dict
-        end
-      end
-
-      def has_key?(dict, key) do
-        match? {:ok, _}, fetch(dict, key)
-      end
-
-      def put_new(dict, key, value) do
-        case has_key?(dict, key) do
-          true  -> dict
-          false -> put(dict, key, value)
-        end
-      end
-
-      def put_new_lazy(dict, key, fun) when is_function(fun, 0) do
-        case has_key?(dict, key) do
-          true  -> dict
-          false -> put(dict, key, fun.())
-        end
-      end
-
-      def drop(dict, keys) do
-        Enum.reduce(keys, dict, &delete(&2, &1))
-      end
-
-      def take(dict, keys) do
-        Enum.reduce(keys, new(), fn key, acc ->
-          case fetch(dict, key) do
-            {:ok, value} -> put(acc, key, value)
-            :error -> acc
-          end
-        end)
-      end
-
-      def to_list(dict) do
-        reduce(dict, {:cont, []}, fn
-          kv, acc -> {:cont, [kv | acc]}
-        end) |> elem(1) |> :lists.reverse
-      end
-
-      def keys(dict) do
-        reduce(dict, {:cont, []}, fn
-          {k, _}, acc -> {:cont, [k | acc]}
-        end) |> elem(1) |> :lists.reverse
-      end
-
-      def values(dict) do
-        reduce(dict, {:cont, []}, fn
-          {_, v}, acc -> {:cont, [v | acc]}
-        end) |> elem(1) |> :lists.reverse
-      end
-
-      def equal?(dict1, dict2) do
-        # Use this import to avoid conflicts in the user code
-        import Kernel, except: [size: 1]
-
-        case size(dict1) == size(dict2) do
-          false -> false
-          true  ->
-            reduce(dict1, {:cont, true}, fn({k, v}, _acc) ->
-              case fetch(dict2, k) do
-                {:ok, ^v} -> {:cont, true}
-                _ -> {:halt, false}
-              end
-            end) |> elem(1)
-        end
-      end
-
-      def merge(dict1, dict2, fun \\ fn(_k, _v1, v2) -> v2 end) do
-        # Use this import to avoid conflicts in the user code
-        import Kernel, except: [size: 1]
-
-        if size(dict1) < size(dict2) do
-          reduce(dict1, {:cont, dict2}, fn {k, v1}, acc ->
-            {:cont, update(acc, k, v1, &fun.(k, v1, &1))}
-          end)
-        else
-          reduce(dict2, {:cont, dict1}, fn {k, v2}, acc ->
-            {:cont, update(acc, k, v2, &fun.(k, &1, v2))}
-          end)
-        end |> elem(1)
-      end
-
-      def update(dict, key, initial, fun) do
-        case fetch(dict, key) do
-          {:ok, value} ->
-            put(dict, key, fun.(value))
-          :error ->
-            put(dict, key, initial)
-        end
-      end
-
-      def update!(dict, key, fun) do
-        case fetch(dict, key) do
-          {:ok, value} ->
-            put(dict, key, fun.(value))
-          :error ->
-            raise KeyError, key: key, term: dict
-        end
-      end
-
-      def pop(dict, key, default \\ nil) do
-        case fetch(dict, key) do
-          {:ok, value} ->
-            {value, delete(dict, key)}
-          :error ->
-            {default, dict}
-        end
-      end
-
-      def pop_lazy(dict, key, fun) when is_function(fun, 0) do
-        case fetch(dict, key) do
-          {:ok, value} ->
-            {value, delete(dict, key)}
-          :error ->
-            {fun.(), dict}
-        end
-      end
-
-      def split(dict, keys) do
-        Enum.reduce(keys, {new(), dict}, fn key, {inc, exc} = acc ->
-          case fetch(exc, key) do
-            {:ok, value} ->
-              {put(inc, key, value), delete(exc, key)}
-            :error ->
-              acc
-          end
-        end)
-      end
-
-      defoverridable merge: 2, merge: 3, equal?: 2, to_list: 1, keys: 1,
-                     values: 1, take: 2, drop: 2, get: 2, get: 3, fetch!: 2,
-                     has_key?: 2, put_new: 3, pop: 2, pop: 3, split: 2,
-                     update: 4, update!: 3, get_and_update: 3, get_lazy: 3,
-                     pop_lazy: 3, put_new_lazy: 3
-    end
-  end
-
-  defmacrop target(dict) do
-    quote do
-      case unquote(dict) do
-        %{__struct__: x} when is_atom(x) ->
-          x
-        %{} ->
-          Map
-        x when is_list(x) ->
-          Keyword
-        x ->
-          unsupported_dict(x)
-      end
-    end
-  end
-
-  @spec keys(t) :: [key]
-  def keys(dict) do
-    target(dict).keys(dict)
-  end
-
-  @spec values(t) :: [value]
-  def values(dict) do
-    target(dict).values(dict)
-  end
-
-  @spec size(t) :: non_neg_integer
-  def size(dict) do
-    target(dict).size(dict)
-  end
-
-  @spec has_key?(t, key) :: boolean
-  def has_key?(dict, key) do
-    target(dict).has_key?(dict, key)
-  end
-
-  @spec get(t, key, value) :: value
-  def get(dict, key, default \\ nil) do
-    target(dict).get(dict, key, default)
-  end
-
-  @spec get_lazy(t, key, (() -> value)) :: value
-  def get_lazy(dict, key, fun) do
-    target(dict).get_lazy(dict, key, fun)
-  end
-
-  @spec get_and_update(t, key, (value -> {value, value})) :: {value, t}
-  def get_and_update(dict, key, fun) do
-    target(dict).get_and_update(dict, key, fun)
-  end
-
-  @spec fetch(t, key) :: value
-  def fetch(dict, key) do
-    target(dict).fetch(dict, key)
-  end
-
-  @spec fetch!(t, key) :: value | no_return
-  def fetch!(dict, key) do
-    target(dict).fetch!(dict, key)
-  end
-
-  @spec put(t, key, value) :: t
-  def put(dict, key, val) do
-    target(dict).put(dict, key, val)
-  end
-
-  @spec put_new(t, key, value) :: t
-  def put_new(dict, key, val) do
-    target(dict).put_new(dict, key, val)
-  end
-
-  @spec put_new_lazy(t, key, (() -> value)) :: t
-  def put_new_lazy(dict, key, fun) do
-    target(dict).put_new_lazy(dict, key, fun)
-  end
-
-  @spec delete(t, key) :: t
-  def delete(dict, key) do
-    target(dict).delete(dict, key)
-  end
-
-  @spec merge(t, t) :: t
-  def merge(dict1, dict2) do
-    target1 = target(dict1)
-    target2 = target(dict2)
-
-    if target1 == target2 do
-      target1.merge(dict1, dict2)
-    else
-      do_merge(target1, dict1, dict2, fn(_k, _v1, v2) -> v2 end)
-    end
-  end
-
-  @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(dict1, dict2, fun) do
-    target1 = target(dict1)
-    target2 = target(dict2)
-
-    if target1 == target2 do
-      target1.merge(dict1, dict2, fun)
-    else
-      do_merge(target1, dict1, dict2, fun)
-    end
-  end
-
-  defp do_merge(target1, dict1, dict2, fun) do
-    Enumerable.reduce(dict2, {:cont, dict1}, fn({k, v}, acc) ->
-      {:cont, target1.update(acc, k, v, fn(other) -> fun.(k, other, v) end)}
-    end) |> elem(1)
-  end
-
-  @spec pop(t, key, value) :: {value, t}
-  def pop(dict, key, default \\ nil) do
-    target(dict).pop(dict, key, default)
-  end
-
-  @spec pop_lazy(t, key, (() -> value)) :: {value, t}
-  def pop_lazy(dict, key, fun) do
-    target(dict).pop_lazy(dict, key, fun)
-  end
-
-  @spec update!(t, key, (value -> value)) :: t
-  def update!(dict, key, fun) do
-    target(dict).update!(dict, key, fun)
-  end
-
-  @spec update(t, key, value, (value -> value)) :: t
-  def update(dict, key, initial, fun) do
-    target(dict).update(dict, key, initial, fun)
-  end
-
-  @spec split(t, [key]) :: {t, t}
-  def split(dict, keys) do
-    target(dict).split(dict, keys)
-  end
-
-  @spec drop(t, [key]) :: t
-  def drop(dict, keys) do
-    target(dict).drop(dict, keys)
-  end
-
-  @spec take(t, [key]) :: t
-  def take(dict, keys) do
-    target(dict).take(dict, keys)
-  end
-
-  @spec empty(t) :: t
-  def empty(dict) do
-    target(dict).empty(dict)
-  end
-
-  @spec equal?(t, t) :: boolean
-  def equal?(dict1, dict2) do
-    target1 = target(dict1)
-    target2 = target(dict2)
-
-    cond do
-      target1 == target2 ->
-        target1.equal?(dict1, dict2)
-
-      target1.size(dict1) == target2.size(dict2) ->
-        Enumerable.reduce(dict2, {:cont, true}, fn({k, v}, _acc) ->
-          case target1.fetch(dict1, k) do
-            {:ok, ^v} -> {:cont, true}
-            _         -> {:halt, false}
-          end
-        end) |> elem(1)
-
-      true ->
-        false
-    end
-  end
-
-  @spec to_list(t) :: list
-  def to_list(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
-end

lib/elixir/lib/file/stat.ex

@@ -1,77 +0,0 @@
-require Record
-
-defmodule File.Stat do
-  @moduledoc """
-  A struct that holds file information.
-
-  In Erlang, this struct is represented by a `:file_info` record.
-  Therefore this module also provides functions for converting
-  between the Erlang record and the Elixir struct.
-
-  Its fields are:
-
-    * `size` - size of file in bytes.
-
-    * `type` - `:device | :directory | :regular | :other`; the type of the
-      file.
-
-    * `access` - `:read | :write | :read_write | :none`; the current system
-      access to the file.
-
-    * `atime` - the last time the file was read.
-
-    * `mtime` - the last time the file was written.
-
-    * `ctime` - the interpretation of this time field depends on the operating
-      system. On Unix, it is the last time the file or the inode was changed.
-      In Windows, it is the time of creation.
-
-    * `mode` - the file permissions.
-
-    * `links` - the number of links to this file. This is always 1 for file
-      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
-      B:, and so on.
-
-    * `minor_device` - only valid for character devices on Unix. In all other
-      cases, this field is zero.
-
-    * `inode` - gives the inode number. On non-Unix file systems, this field
-      will be zero.
-
-    * `uid` - indicates the owner of the file. Will be zero for non-Unix file
-      systems.
-
-    * `gid` - indicates the group that owns the file. Will be zero for
-      non-Unix file systems.
-
-  The time type returned in `atime`, `mtime`, and `ctime` is dependent on the
-  time type set in options. `{:time, type}` where type can be `:local`,
-  `:universal`, or `:posix`. Default is `:universal`.
-  """
-
-  record = Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-  keys   = :lists.map(&elem(&1, 0), record)
-  vals   = :lists.map(&{&1, [], nil}, keys)
-  pairs  = :lists.zip(keys, vals)
-
-  defstruct keys
-  @type t :: %__MODULE__{}
-
-  @doc """
-  Converts a `File.Stat` struct to a `:file_info` record.
-  """
-  def to_record(%File.Stat{unquote_splicing(pairs)}) do
-    {:file_info, unquote_splicing(vals)}
-  end
-
-  @doc """
-  Converts a `:file_info` record into a `File.Stat`.
-  """
-  def from_record(file_info)
-  def from_record({:file_info, unquote_splicing(vals)}) do
-    %File.Stat{unquote_splicing(pairs)}
-  end
-end

lib/elixir/lib/file/stream.ex

@@ -1,158 +0,0 @@
-defmodule File.Stream do
-  @moduledoc """
-  Defines a `File.Stream` struct returned by `File.stream!/3`.
-
-  The following fields are public:
-
-    * `path`          - the file path
-    * `modes`         - the file modes
-    * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given amount of bytes
-
-  """
-
-  defstruct path: nil, modes: [], line_or_bytes: :line, raw: true
-
-  @type t :: %__MODULE__{}
-
-  @doc false
-  def __build__(path, modes, line_or_bytes) 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
-      end
-
-    %File.Stream{path: path, modes: modes, raw: raw, line_or_bytes: line_or_bytes}
-  end
-
-  defimpl Collectable do
-    def into(%{path: path, modes: modes, raw: raw} = stream) do
-      modes = for mode <- modes, mode not in [:read], do: mode
-
-      case :file.open(path, [:write | modes]) do
-        {:ok, device} ->
-          {:ok, into(device, stream, raw)}
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    defp into(device, stream, raw) do
-      fn
-        :ok, {:cont, x} ->
-          case raw do
-            true  -> IO.binwrite(device, x)
-            false -> IO.write(device, x)
-          end
-        :ok, :done ->
-          # If delayed_write option is used and the last write failed will
-          # MatchError here as {:error, _} is returned.
-          :ok = :file.close(device)
-          stream
-        :ok, :halt ->
-          # If delayed_write option is used and the last write failed will
-          # MatchError here as {:error, _} is returned.
-          :ok = :file.close(device)
-      end
-    end
-  end
-
-  defimpl Enumerable do
-    @read_ahead_size 64 * 1024
-
-    def reduce(%{path: path, modes: modes, line_or_bytes: line_or_bytes, raw: raw}, acc, fun) do
-      start_fun =
-        fn ->
-          case :file.open(path, read_modes(modes)) do
-            {:ok, device} ->
-              if :trim_bom in modes, do: trim_bom(device), else: device
-            {:error, reason} ->
-              raise File.Error, reason: reason, action: "stream", path: path
-          end
-        end
-
-      next_fun =
-        case raw do
-          true  -> &IO.each_binstream(&1, line_or_bytes)
-          false -> &IO.each_stream(&1, line_or_bytes)
-        end
-
-      Stream.resource(start_fun, next_fun, &:file.close/1).(acc, fun)
-    end
-
-    def count(%{path: path, modes: modes, line_or_bytes: :line} = stream) do
-      pattern = :binary.compile_pattern("\n")
-      counter = &count_lines(&1, path, pattern, read_function(stream), 0)
-
-      case File.open(path, read_modes(modes), counter) do
-        {:ok, count} ->
-          {:ok, count}
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    def count(%{path: path, line_or_bytes: bytes}) do
-      case File.stat(path) do
-        {:ok, %{size: 0}} ->
-          {:error, __MODULE__}
-        {:ok, %{size: size}} ->
-          {:ok, div(size, bytes) + if(rem(size, bytes) == 0, do: 0, else: 1)}
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    def member?(_stream, _term) do
-      {:error, __MODULE__}
-    end
-
-    defp trim_bom(device) do
-      header = IO.binread(device, 4)
-      {:ok, _new_pos} = :file.position(device, bom_length(header))
-      device
-    end
-
-    defp bom_length(<<239, 187, 191, _rest::binary>>),
-      do: 3
-    defp bom_length(<<254, 255, _rest::binary>>),
-      do: 2
-    defp bom_length(<<255, 254, _rest::binary>>),
-      do: 2
-    defp bom_length(<<0, 0, 254, 255, _rest::binary>>),
-      do: 4
-    defp bom_length(<<254, 255, 0, 0, _rest::binary>>),
-      do: 4
-    defp bom_length(_binary),
-      do: 0
-
-    defp read_modes(modes) do
-      for mode <- modes, mode not in [:write, :append, :trim_bom], do: mode
-    end
-
-    defp count_lines(device, path, pattern, read, count) do
-      case read.(device) do
-        data when is_binary(data) ->
-          count_lines(device, path, pattern, read, count + count_lines(data, pattern))
-        :eof ->
-          count
-        {:error, reason} ->
-          raise File.Error, reason: reason, action: "stream", path: path
-      end
-    end
-
-    defp count_lines(data, pattern), do: length(:binary.matches(data, pattern))
-
-    defp read_function(%{raw: true}), do: &IO.binread(&1, @read_ahead_size)
-    defp read_function(%{raw: false}), do: &IO.read(&1, @read_ahead_size)
-  end
-end

lib/elixir/lib/float.ex

@@ -1,448 +0,0 @@
-import Kernel, except: [round: 1]
-
-defmodule Float do
-  @moduledoc """
-  Functions for working with floating-point numbers.
-  """
-
-  import Bitwise
-
-  @power_of_2_to_52 4503599627370496
-  @precision_range 0..15
-  @type precision_range :: 0..15
-
-  @doc """
-  Parses a binary into a float.
-
-  If successful, returns a tuple in the form of `{float, remainder_of_binary}`;
-  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,
-  `String.to_float/1` can be used instead.
-
-  ## Examples
-
-      iex> Float.parse("34")
-      {34.0, ""}
-      iex> Float.parse("34.25")
-      {34.25, ""}
-      iex> Float.parse("56.5xyz")
-      {56.5, "xyz"}
-
-      iex> Float.parse("pi")
-      :error
-
-  """
-  @spec parse(binary) :: {float, binary} | :error
-  def parse("-" <> binary) do
-    case parse_unsigned(binary) do
-      :error -> :error
-      {number, remainder} -> {-number, remainder}
-    end
-  end
-
-  def parse("+" <> binary) do
-    parse_unsigned(binary)
-  end
-
-  def parse(binary) do
-    parse_unsigned(binary)
-  end
-
-  defp parse_unsigned(<<digit, rest::binary>>) when digit in ?0..?9, do:
-    parse_unsigned(rest, false, false, <<digit>>)
-
-  defp parse_unsigned(binary) when is_binary(binary), do:
-    :error
-
-  defp parse_unsigned(<<digit, rest::binary>>, dot?, e?, acc) when digit in ?0..?9, do:
-    parse_unsigned(rest, dot?, e?, <<acc::binary, digit>>)
-
-  defp parse_unsigned(<<?., digit, rest::binary>>, false, false, acc) when digit in ?0..?9, do:
-    parse_unsigned(rest, true, false, <<acc::binary, ?., digit>>)
-
-  defp parse_unsigned(<<exp_marker, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and  digit in ?0..?9, do:
-    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, digit>>)
-
-  defp parse_unsigned(<<exp_marker, sign, digit, rest::binary>>, dot?, false, acc) when exp_marker in 'eE' and sign in '-+' and digit in ?0..?9, do:
-    parse_unsigned(rest, true, true, <<add_dot(acc, dot?)::binary, ?e, sign, digit>>)
-
-  defp parse_unsigned(rest, dot?, _e?, acc), do:
-    {:erlang.binary_to_float(add_dot(acc, dot?)), rest}
-
-  defp add_dot(acc, true),  do: acc
-  defp add_dot(acc, false), do: acc <> ".0"
-
-  @doc """
-  Rounds a float to the largest integer less than or equal to `num`.
-
-  `floor/2` also accepts a precision to round a floating-point value down
-  to an arbitrary number of fractional digits (between 0 and 15).
-  The operation is performed on the binary floating point, without a
-  conversion to decimal.
-
-  The behaviour of `floor/2` for floats can be surprising. For example:
-
-      iex> Float.floor(12.52, 2)
-      12.51
-
-  One may have expected it to floor to 12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 12.51999999,
-  which explains the behaviour above.
-
-  This function always returns a float. `Kernel.trunc/1` may be used instead to
-  truncate the result to an integer afterwards.
-
-  ## Examples
-
-      iex> Float.floor(34.25)
-      34.0
-      iex> Float.floor(-56.5)
-      -57.0
-      iex> Float.floor(34.259, 2)
-      34.25
-
-  """
-  @spec floor(float, precision_range) :: float
-  def floor(number, precision \\ 0)
-
-  def floor(number, precision) when is_float(number) and precision in @precision_range do
-    round(number, precision, :floor)
-  end
-
-  def floor(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  @doc """
-  Rounds a float to the smallest integer greater than or equal to `num`.
-
-  `ceil/2` also accepts a precision to round a floating-point value down
-  to an arbitrary number of fractional digits (between 0 and 15).
-
-  The operation is performed on the binary floating point, without a
-  conversion to decimal.
-
-  The behaviour of `ceil/2` for floats can be surprising. For example:
-
-      iex> Float.ceil(-12.52, 2)
-      -12.51
-
-  One may have expected it to ceil to -12.52. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as -12.51999999,
-  which explains the behaviour above.
-
-  This function always returns floats. `Kernel.trunc/1` may be used instead to
-  truncate the result to an integer afterwards.
-
-  ## Examples
-
-      iex> Float.ceil(34.25)
-      35.0
-      iex> Float.ceil(-56.5)
-      -56.0
-      iex> Float.ceil(34.251, 2)
-      34.26
-
-  """
-  @spec ceil(float, precision_range) :: float
-  def ceil(number, precision \\ 0)
-
-  def ceil(number, precision) when is_float(number) and precision in @precision_range do
-    round(number, precision, :ceil)
-  end
-
-  def ceil(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  @doc """
-  Rounds a floating-point value to an arbitrary number of fractional
-  digits (between 0 and 15).
-
-  The rounding direction always ties to half up. The operation is
-  performed on the binary floating point, without a conversion to decimal.
-
-  This function only accepts floats and always returns a float. Use
-  `Kernel.round/1` if you want a function that accepts both floats
-  and integers and always returns an integer.
-
-  The behaviour of `round/2` for floats can be surprising. For example:
-
-      iex> Float.round(5.5675, 3)
-      5.567
-
-  One may have expected it to round to the half up 5.568. This is not a bug.
-  Most decimal fractions cannot be represented as a binary floating point
-  and therefore the number above is internally represented as 5.567499999,
-  which explains the behaviour above. If you want exact rounding for decimals,
-  you must use a decimal library. The behaviour above is also in accordance
-  to reference implementations, such as "Correctly Rounded Binary-Decimal and
-  Decimal-Binary Conversions" by David M. Gay.
-
-  ## Examples
-
-      iex> Float.round(12.5)
-      13.0
-      iex> Float.round(5.5674, 3)
-      5.567
-      iex> Float.round(5.5675, 3)
-      5.567
-      iex> Float.round(-5.5674, 3)
-      -5.567
-      iex> Float.round(-5.5675)
-      -6.0
-      iex> Float.round(12.341444444444441, 15)
-      12.341444444444441
-
-  """
-  @spec round(float, precision_range) :: float
-  # This implementation is slow since it relies on big integers.
-  # Faster implementations are available on more recent papers
-  # and could be implemented in the future.
-  def round(float, precision \\ 0)
-
-  def round(float, precision) when is_float(float) and precision in @precision_range do
-    round(float, precision, :half_up)
-  end
-
-  def round(number, precision) when is_float(number) do
-    raise ArgumentError, invalid_precision_message(precision)
-  end
-
-  defp round(float, precision, rounding) do
-    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
-    {num, count, _} = decompose(significant)
-    count = count - exp + 1023
-
-    cond do
-      count <= 0 or  # There is no decimal precision
-      (0 == exp and <<0::52>> == significant) -> #zero or minus zero
-        float
-
-      count >= 104 -> # Precision beyond 15 digits
-        case rounding do
-          :ceil when sign === 0 -> 1 / power_of_10(precision)
-          :floor when sign === 1 -> -1 / power_of_10(precision)
-          _ -> 0.0
-        end
-
-      count <= precision -> # We are asking more precision than we have
-        float
-
-      true ->
-        # Difference in precision between float and asked precision
-        # We subtract 1 because we need to calculate the remainder too
-        diff = count - precision - 1
-
-        # Get up to latest so we calculate the remainder
-        power_of_10 = power_of_10(diff)
-
-        # Convert the numerand to decimal base
-        num = num * power_of_5(count)
-
-        # Move to the given precision - 1
-        num = div(num, power_of_10)
-        div = div(num, 10)
-        num = rounding(rounding, sign, num, div)
-
-        # Convert back to float without loss
-        # http://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/
-        den = power_of_10(precision)
-        boundary = den <<< 52
-
-        cond do
-          num == 0 ->
-            0.0
-          num >= boundary ->
-            {den, exp} = scale_down(num, boundary, 52)
-            decimal_to_float(sign, num, den, exp)
-          true ->
-            {num, exp} = scale_up(num, boundary, 52)
-            decimal_to_float(sign, num, den, exp)
-        end
-    end
-  end
-
-  defp scale_up(num, boundary, exp) when num >= boundary, do: {num, exp}
-  defp scale_up(num, boundary, exp), do: scale_up(num <<< 1, boundary, exp - 1)
-
-  defp scale_down(num, den, exp) do
-    new_den = den <<< 1
-    if num < new_den do
-      {den >>> 52, exp}
-    else
-      scale_down(num, new_den, exp + 1)
-    end
-  end
-
-  defp decimal_to_float(sign, num, den, exp) do
-    quo = div(num, den)
-    rem = num - quo * den
-
-    tmp =
-      case den >>> 1 do
-        den when rem > den -> quo + 1
-        den when rem < den -> quo
-        _ when (quo &&& 1) === 1 -> quo + 1
-        _ -> quo
-      end
-
-    tmp = tmp - @power_of_2_to_52
-    <<tmp::float>> = <<sign::1, (exp + 1023)::11, tmp::52>>
-    tmp
-  end
-
-  defp rounding(:floor, 1, _num, div), do: div + 1
-  defp rounding(:ceil, 0, _num, div), do: div + 1
-  defp rounding(:half_up, _sign, num, div) do
-    case rem(num, 10) do
-      rem when rem < 5 -> div
-      rem when rem >= 5 -> div + 1
-    end
-  end
-  defp rounding(_, _, _, div), do: div
-
-  Enum.reduce 0..104, 1, fn x, acc ->
-    defp power_of_10(unquote(x)), do: unquote(acc)
-    acc * 10
-  end
-
-  Enum.reduce 0..104, 1, fn x, acc ->
-    defp power_of_5(unquote(x)), do: unquote(acc)
-    acc * 5
-  end
-
-  @doc """
-  Returns a pair of integers whose ratio is exactly equal
-  to the original float and with a positive denominator.
-
-  ## Examples
-
-      iex> Float.ratio(3.14)
-      {7070651414971679, 2251799813685248}
-      iex> Float.ratio(-3.14)
-      {-7070651414971679, 2251799813685248}
-      iex> Float.ratio(1.5)
-      {3, 2}
-      iex> Float.ratio(-1.5)
-      {-3, 2}
-      iex> Float.ratio(16.0)
-      {16, 1}
-      iex> Float.ratio(-16.0)
-      {-16, 1}
-
-  """
-  def ratio(float) when is_float(float) do
-    <<sign::1, exp::11, significant::52-bitstring>> = <<float::float>>
-    {num, _, den} = decompose(significant)
-    num = sign(sign, num)
-    case exp - 1023 do
-      exp when exp > 0 ->
-        {den, exp} = shift_right(den, exp)
-        {shift_left(num, exp), den}
-      exp when exp < 0 ->
-        {num, shift_left(den, -exp)}
-      0 ->
-        {num, den}
-    end
-  end
-
-  defp decompose(significant) do
-    decompose(significant, 1, 0, 2, 1, 1)
-  end
-
-  defp decompose(<<1::1, bits::bitstring>>, count, last_count, power, _last_power, acc) do
-    decompose(bits, count + 1, count, power <<< 1, power, shift_left(acc, count - last_count) + 1)
-  end
-  defp decompose(<<0::1, bits::bitstring>>, count, last_count, power, last_power, acc) do
-    decompose(bits, count + 1, last_count, power <<< 1, last_power, acc)
-  end
-  defp decompose(<<>>, _count, last_count, _power, last_power, acc) do
-    {acc, last_count, last_power}
-  end
-
-  defp sign(0, num), do: num
-  defp sign(1, num), do: -num
-
-  defp shift_left(num, 0), do: num
-  defp shift_left(num, times), do: shift_left(num <<< 1, times - 1)
-
-  defp shift_right(num, 0), do: {num, 0}
-  defp shift_right(1, times), do: {1, times}
-  defp shift_right(num, times), do: shift_right(num >>> 1, times - 1)
-
-  @doc """
-  Returns a charlist which corresponds to the text representation
-  of the given float.
-
-  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.
-
-  ## Examples
-
-      iex> Float.to_charlist(7.0)
-      '7.0'
-
-  """
-  @spec to_charlist(float) :: charlist
-  def to_charlist(float) when is_float(float) do
-    :io_lib_format.fwrite_g(float)
-  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.
-
-  ## Examples
-
-      iex> Float.to_string(7.0)
-      "7.0"
-
-  """
-  @spec to_string(float) :: String.t
-  def to_string(float) when is_float(float) do
-    IO.iodata_to_binary(:io_lib_format.fwrite_g(float))
-  end
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  def to_char_list(float), do: Float.to_charlist(float)
-
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def to_char_list(float, options) do
-    :erlang.float_to_list(float, expand_compact(options))
-  end
-
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def to_string(float, options) do
-    :erlang.float_to_binary(float, expand_compact(options))
-  end
-
-  defp invalid_precision_message(precision) do
-    "precision #{precision} is out of valid range of #{inspect @precision_range}"
-  end
-
-  defp expand_compact([{:compact, false} | t]), do: expand_compact(t)
-  defp expand_compact([{:compact, true} | t]),  do: [:compact | expand_compact(t)]
-  defp expand_compact([h | t]),                 do: [h | expand_compact(t)]
-  defp expand_compact([]),                      do: []
-end

lib/elixir/lib/gen_event.ex

@@ -1,810 +0,0 @@
-defmodule GenEvent do
-  # TODO: Remove by 2.0
-
-  # Functions from this module are deprecated in elixir_dispatch.
-
-  @moduledoc """
-  WARNING: this module is deprecated.
-
-  If you are interested in implementing an event manager, please read the
-  "Alternatives" section below. If you have to implement an event handler to
-  integrate with an existing system, such as Elixir's Logger, please use
-  `:gen_event` instead.
-
-  ## Alternatives
-
-  There are a few suitable alternatives to replace GenEvent. Each of them can be
-  the most beneficial based on the use case.
-
-  ### Supervisor and GenServers
-
-  One alternative to GenEvent is a very minimal solution consisting of using a
-  supervisor and multiple GenServers started under it. The supervisor acts as
-  the "event manager" and the children GenServers act as the "event handlers".
-  This approach has some shortcomings (it provides no backpressure for example)
-  but can still replace GenEvent for low-profile usages of it. [This blog post
-  by José
-  Valim](http://blog.plataformatec.com.br/2016/11/replacing-genevent-by-a-supervisor-genserver/)
-  has more detailed information on this approach.
-
-  ### GenStage
-
-  If the use case where you were using GenEvent requires more complex logic,
-  [GenStage](https://github.com/elixir-lang/gen_stage) provides a great
-  alternative. GenStage is an external Elixir library maintained by the Elixir
-  team; it provides tool to implement systems that exchange events in a
-  demand-driven way with built-in support for backpressure. See the [GenStage
-  documentation](https://hexdocs.pm/gen_stage) for more information.
-
-  ### `:gen_event`
-
-  If your use case requires exactly what GenEvent provided, or you have to
-  integrate with an existing `:gen_event`-based system, you can still use the
-  [`:gen_event`](http://erlang.org/doc/man/gen_event.html) Erlang module.
-  """
-
-  @callback init(args :: term) ::
-    {:ok, state} |
-    {:ok, state, :hibernate} |
-    {:error, reason :: any} when state: any
-
-  @callback handle_event(event :: term, state :: term) ::
-    {:ok, new_state} |
-    {:ok, new_state, :hibernate} |
-    :remove_handler when new_state: term
-
-  @callback handle_call(request :: term, state :: term) ::
-    {:ok, reply, new_state} |
-    {:ok, reply, new_state, :hibernate} |
-    {:remove_handler, reply} when reply: term, new_state: term
-
-  @callback handle_info(msg :: term, state :: term) ::
-    {:ok, new_state} |
-    {:ok, new_state, :hibernate} |
-    :remove_handler when new_state: term
-
-  @callback terminate(reason, state :: term) ::
-    term when reason: :stop | {:stop, term} | :remove_handler | {:error, term} | term
-
-  @callback code_change(old_vsn, state :: term, extra :: term) ::
-    {:ok, new_state :: term} when old_vsn: term | {:down, term}
-
-  @type on_start :: {:ok, pid} | {:error, {:already_started, pid}}
-
-  @type name :: atom | {:global, term} | {:via, module, term}
-
-  @type options :: [name: name]
-
-  @type manager :: pid | name | {atom, node}
-
-  @type handler :: atom | {atom, term}
-
-  @doc false
-  defmacro __using__(_) do
-    %{file: file, line: line} = __CALLER__
-    deprecation_message = "the GenEvent module is deprecated, see its documentation for alternatives"
-    :elixir_errors.warn(line, file, deprecation_message)
-
-    quote location: :keep do
-      @behaviour :gen_event
-
-      @doc false
-      def init(args) do
-        {:ok, args}
-      end
-
-      @doc false
-      def handle_event(_event, state) do
-        {:ok, state}
-      end
-
-      @doc false
-      def handle_call(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to call GenEvent #{inspect proc} but no handle_call/2 clause was provided"
-          1 -> {:remove_handler, {:bad_call, msg}}
-        end
-      end
-
-      @doc false
-      def handle_info(_msg, state) do
-        {:ok, state}
-      end
-
-      @doc false
-      def terminate(_reason, _state) do
-        :ok
-      end
-
-      @doc false
-      def code_change(_old, state, _extra) do
-        {:ok, state}
-      end
-
-      defoverridable [init: 1, handle_event: 2, handle_call: 2,
-                      handle_info: 2, terminate: 2, code_change: 3]
-    end
-  end
-
-  @doc false
-  @spec start_link(options) :: on_start
-  def start_link(options \\ []) when is_list(options) do
-    do_start(:link, options)
-  end
-
-  @doc false
-  @spec start(options) :: on_start
-  def start(options \\ []) when is_list(options) do
-    do_start(:nolink, options)
-  end
-
-  @no_callback :"no callback module"
-
-  defp do_start(mode, options) do
-    case Keyword.get(options, :name) do
-      nil ->
-        :gen.start(GenEvent, mode, @no_callback, [], [])
-      atom when is_atom(atom) ->
-        :gen.start(GenEvent, mode, {:local, atom}, @no_callback, [], [])
-      {:global, _term} = tuple ->
-        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-      {:via, via_module, _term} = tuple when is_atom(via_module) ->
-        :gen.start(GenEvent, mode, tuple, @no_callback, [], [])
-      other ->
-        raise ArgumentError, """
-        expected :name option to be one of:
-
-          * nil
-          * atom
-          * {:global, term}
-          * {:via, module, term}
-
-        Got: #{inspect(other)}
-        """
-    end
-  end
-
-  @doc false
-  @spec stream(manager, keyword) :: GenEvent.Stream.t
-  def stream(manager, options \\ []) do
-    %GenEvent.Stream{
-      manager: manager,
-      timeout: Keyword.get(options, :timeout, :infinity)}
-  end
-
-  @doc false
-  @spec add_handler(manager, handler, term) :: :ok | {:error, term}
-  def add_handler(manager, handler, args) do
-    rpc(manager, {:add_handler, handler, args})
-  end
-
-  @doc false
-  @spec add_mon_handler(manager, handler, term) :: :ok | {:error, term}
-  def add_mon_handler(manager, handler, args) do
-    rpc(manager, {:add_mon_handler, handler, args, self()})
-  end
-
-  @doc false
-  @spec notify(manager, term) :: :ok
-  def notify(manager, event)
-
-  def notify({:global, name}, msg) do
-    try do
-      :global.send(name, {:notify, msg})
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  end
-
-  def notify({:via, mod, name}, msg) when is_atom(mod) do
-    try do
-      mod.send(name, {:notify, msg})
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  end
-
-  def notify(manager, msg)
-      when is_pid(manager)
-      when is_atom(manager)
-      when tuple_size(manager) == 2 and
-        is_atom(elem(manager, 0)) and is_atom(elem(manager, 1)) do
-    send(manager, {:notify, msg})
-    :ok
-  end
-
-  @doc false
-  @spec sync_notify(manager, term) :: :ok
-  def sync_notify(manager, event) do
-    rpc(manager, {:sync_notify, event})
-  end
-
-  @doc false
-  @spec ack_notify(manager, term) :: :ok
-  def ack_notify(manager, event) do
-    rpc(manager, {:ack_notify, event})
-  end
-
-  @doc false
-  @spec call(manager, handler, term, timeout) ::  term | {:error, term}
-  def call(manager, handler, request, timeout \\ 5000) do
-    try do
-      :gen.call(manager, self(), {:call, handler, request}, timeout)
-    catch
-      :exit, reason ->
-        exit({reason, {__MODULE__, :call, [manager, handler, request, timeout]}})
-    else
-      {:ok, res} -> res
-    end
-  end
-
-  @doc false
-  @spec remove_handler(manager, handler, term) :: term | {:error, term}
-  def remove_handler(manager, handler, args) do
-    rpc(manager, {:delete_handler, handler, args})
-  end
-
-  @doc false
-  @spec swap_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
-  def swap_handler(manager, handler1, args1, handler2, args2) do
-    rpc(manager, {:swap_handler, handler1, args1, handler2, args2})
-  end
-
-  @doc false
-  @spec swap_mon_handler(manager, handler, term, handler, term) :: :ok | {:error, term}
-  def swap_mon_handler(manager, handler1, args1, handler2, args2) do
-    rpc(manager, {:swap_mon_handler, handler1, args1, handler2, args2, self()})
-  end
-
-  @doc false
-  @spec which_handlers(manager) :: [handler]
-  def which_handlers(manager) do
-    rpc(manager, :which_handlers)
-  end
-
-  @doc false
-  @spec stop(manager, reason :: term, timeout) :: :ok
-  def stop(manager, reason \\ :normal, timeout \\ :infinity) do
-    :gen.stop(manager, reason, timeout)
-  end
-
-  defp rpc(module, cmd) do
-    {:ok, reply} = :gen.call(module, self(), cmd, :infinity)
-    reply
-  end
-
-  ## Init callbacks
-
-  require Record
-  Record.defrecordp :handler, [:module, :id, :state, :pid, :ref]
-
-  @doc false
-  def init_it(starter, :self, name, mod, args, options) do
-    init_it(starter, self(), name, mod, args, options)
-  end
-
-  def init_it(starter, parent, name, _mod, _args, 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
-    :proc_lib.init_ack(starter, {:ok, self()})
-    loop(parent, name(name), [], debug, false)
-  end
-
-  @doc false
-  def init_hib(parent, name, handlers, debug) do
-    fetch_msg(parent, name, handlers, debug, true)
-  end
-
-  defp name({:local, name}),  do: name
-  defp name({:global, name}), do: name
-  defp name({:via, _, name}), do: name
-  defp name(pid) when is_pid(pid), do: pid
-
-  ## Loop
-
-  defp loop(parent, name, handlers, debug, true) do
-    :proc_lib.hibernate(__MODULE__, :init_hib, [parent, name, handlers, debug])
-  end
-
-  defp loop(parent, name, handlers, debug, false) do
-    fetch_msg(parent, name, handlers, debug, false)
-  end
-
-  defp fetch_msg(parent, name, handlers, debug, hib) do
-    receive do
-      {:system, from, req} ->
-        :sys.handle_system_msg(req, from, parent, __MODULE__,
-          debug, [name, handlers, hib], hib)
-      {:EXIT, ^parent, reason} ->
-        server_terminate(reason, parent, handlers, name)
-      msg when debug == [] ->
-        handle_msg(msg, parent, name, handlers, [])
-      msg ->
-        debug = :sys.handle_debug(debug, &print_event/3, name, {:in, msg})
-        handle_msg(msg, parent, name, handlers, debug)
-    end
-  end
-
-  defp handle_msg(msg, parent, name, handlers, debug) do
-    case msg do
-      {:notify, event} ->
-        {hib, handlers} = server_event(:async, event, handlers, name)
-        loop(parent, name, handlers, debug, hib)
-      {_from, _tag, {:notify, event}} ->
-        {hib, handlers} = server_event(:async, event, handlers, name)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:ack_notify, event}} ->
-        reply(tag, :ok)
-        {hib, handlers} = server_event(:ack, event, handlers, name)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:sync_notify, event}} ->
-        {hib, handlers} = server_event(:sync, event, handlers, name)
-        reply(tag, :ok)
-        loop(parent, name, handlers, debug, hib)
-      {:DOWN, ref, :process, _pid, reason} = other ->
-        case handle_down(ref, reason, handlers, name) do
-          {:ok, handlers} ->
-            loop(parent, name, handlers, debug, false)
-          :error ->
-            {hib, handlers} = server_info(other, handlers, name)
-            loop(parent, name, handlers, debug, hib)
-        end
-      {_from, tag, {:call, handler, query}} ->
-        {hib, reply, handlers} = server_call(handler, query, handlers, name)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:add_handler, handler, args}} ->
-        {hib, reply, handlers} = server_add_handler(handler, args, handlers)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:add_mon_handler, handler, args, notify}} ->
-        {hib, reply, handlers} = server_add_mon_handler(handler, args, handlers, notify)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:add_process_handler, pid, notify}} ->
-        {hib, reply, handlers} = server_add_process_handler(pid, handlers, notify)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:delete_handler, handler, args}} ->
-        {reply, handlers} = server_remove_handler(handler, args, handlers, name)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, false)
-      {_from, tag, {:swap_handler, handler1, args1, handler2, args2}} ->
-        {hib, reply, handlers} = server_swap_handler(handler1, args1, handler2, args2, handlers, nil, name)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, {:swap_mon_handler, handler1, args1, handler2, args2, mon}} ->
-        {hib, reply, handlers} = server_swap_handler(handler1, args1, handler2, args2, handlers, mon, name)
-        reply(tag, reply)
-        loop(parent, name, handlers, debug, hib)
-      {_from, tag, :which_handlers} ->
-        reply(tag, server_which_handlers(handlers))
-        loop(parent, name, handlers, debug, false)
-      {_from, tag, :get_modules} ->
-        reply(tag, server_get_modules(handlers))
-        loop(parent, name, handlers, debug, false)
-      other ->
-        {hib, handlers} = server_info(other, handlers, name)
-        loop(parent, name, handlers, debug, hib)
-    end
-  end
-
-  ## System callbacks
-
-  @doc false
-  def system_continue(parent, debug, [name, handlers, hib]) do
-    loop(parent, name, handlers, debug, hib)
-  end
-
-  @doc false
-  def system_terminate(reason, parent, _debug, [name, handlers, _hib]) do
-    server_terminate(reason, parent, handlers, name)
-  end
-
-  @doc false
-  def system_code_change([name, handlers, hib], module, old_vsn, extra) do
-    handlers =
-      for handler <- handlers do
-        if handler(handler, :module) == module do
-          {:ok, state} = module.code_change(old_vsn, handler(handler, :state), extra)
-          handler(handler, state: state)
-        else
-          handler
-        end
-      end
-    {:ok, [name, handlers, hib]}
-  end
-
-  @doc false
-  def system_get_state([_name, handlers, _hib]) do
-    tuples = for handler(module: mod, id: id, state: state) <- handlers do
-      {mod, id, state}
-    end
-    {:ok, tuples}
-  end
-
-  @doc false
-  def system_replace_state(fun, [name, handlers, hib]) do
-    {handlers, states} =
-      :lists.unzip(for handler <- handlers do
-        handler(module: mod, id: id, state: state) = handler
-        cur = {mod, id, state}
-        try do
-          new = {^mod, ^id, new_state} = fun.(cur)
-          {handler(handler, state: new_state), new}
-        catch
-          _, _ ->
-            {handler, cur}
-        end
-      end)
-    {:ok, states, [name, handlers, hib]}
-  end
-
-  @doc false
-  def format_status(opt, status_data) do
-    [pdict, sys_state, parent, _debug, [name, handlers, _hib]] = status_data
-    header = :gen.format_status_header('Status for event handler', name)
-
-    formatted = for handler <- handlers do
-      handler(module: module, state: state) = handler
-      if function_exported?(module, :format_status, 2) do
-        try do
-          state = module.format_status(opt, [pdict, state])
-          handler(handler, state: state)
-        catch
-          _, _ -> handler
-        end
-      else
-        handler
-      end
-    end
-
-    [header: header,
-     data: [{'Status', sys_state}, {'Parent', parent}],
-     items: {'Installed handlers', formatted}]
-  end
-
-  ## Loop helpers
-
-  defp print_event(dev, {:in, msg}, name) do
-    case msg do
-      {:notify, event} ->
-        IO.puts dev, "*DBG* #{inspect name} got event #{inspect event}"
-      {_, _, {:call, handler, query}} ->
-        IO.puts dev, "*DBG* #{inspect name} (handler #{inspect handler}) got call #{inspect query}"
-      _ ->
-        IO.puts dev, "*DBG* #{inspect name} got #{inspect msg}"
-    end
-  end
-
-  defp print_event(dev, dbg, name) do
-    IO.puts dev, "*DBG* #{inspect name}: #{inspect dbg}"
-  end
-
-  defp server_add_handler({module, id}, args, handlers) do
-    handler = handler(module: module, id: {module, id})
-    do_add_handler(module, handler, args, handlers, :ok)
-  end
-
-  defp server_add_handler(module, args, handlers) do
-    handler = handler(module: module, id: module)
-    do_add_handler(module, handler, args, handlers, :ok)
-  end
-
-  defp server_add_mon_handler({module, id}, args, handlers, notify) do
-    ref = Process.monitor(notify)
-    handler = handler(module: module, id: {module, id}, pid: notify, ref: ref)
-    do_add_handler(module, handler, args, handlers, :ok)
-  end
-
-  defp server_add_mon_handler(module, args, handlers, notify) do
-    ref = Process.monitor(notify)
-    handler = handler(module: module, id: module, pid: notify, ref: ref)
-    do_add_handler(module, handler, args, handlers, :ok)
-  end
-
-  defp server_add_process_handler(pid, handlers, notify) do
-    ref = Process.monitor(pid)
-    handler = handler(module: GenEvent.Stream, id: {self(), ref},
-                      pid: notify, ref: ref)
-    do_add_handler(GenEvent.Stream, handler, {pid, ref}, handlers, {self(), ref})
-  end
-
-  defp server_remove_handler(module, args, handlers, name) do
-    do_take_handler(module, args, handlers, name, :remove, :normal)
-  end
-
-  defp server_swap_handler(module1, args1, module2, args2, handlers, sup, name) do
-    {state, handlers} =
-      do_take_handler(module1, args1, handlers, name, :swapped, {:swapped, module2, sup})
-
-    if sup do
-      server_add_mon_handler(module2, {args2, state}, handlers, sup)
-    else
-      server_add_handler(module2, {args2, state}, handlers)
-    end
-  end
-
-  defp server_info(event, handlers, name) do
-    handlers = :lists.reverse(handlers)
-    server_notify(event, :handle_info, handlers, name, handlers, [], false)
-  end
-
-  defp server_event(mode, event, handlers, name) do
-    {handlers, streams} = server_split_process_handlers(mode, event, handlers, [], [])
-    {hib, handlers} = server_notify(event, :handle_event, handlers, name, handlers, [], false)
-    {hib, server_collect_process_handlers(mode, event, streams, handlers, name)}
-  end
-
-  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, [handler | handlers], streams)
-    end
-  end
-
-  defp server_split_process_handlers(_mode, _event, [], handlers, streams) do
-    {handlers, streams}
-  end
-
-  defp server_process_notify(mode, event, handler(state: {pid, ref})) do
-    send pid, {self(), {self(), ref}, {mode_to_tag(mode), event}}
-  end
-
-  defp mode_to_tag(:ack),   do: :ack_notify
-  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
-    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)
-      :error ->
-        server_notify(event, fun, t, name, handlers, acc, hib)
-    end
-  end
-
-  defp server_notify(_, _, [], _, _, acc, hib) do
-    {hib, acc}
-  end
-
-  defp server_update(handler, fun, event, name, _handlers) do
-    handler(module: module, state: state) = handler
-
-    case do_handler(module, fun, [event, state]) do
-      {:ok, res} ->
-        case res do
-          {:ok, state} ->
-            {false, handler(handler, state: state)}
-          {:ok, state, :hibernate} ->
-            {true, handler(handler, state: state)}
-          :remove_handler ->
-            do_terminate(handler, :remove_handler, event, name, :normal)
-            :error
-          other ->
-            reason = {:bad_return_value, other}
-            do_terminate(handler, {:error, reason}, event, name, reason)
-            :error
-        end
-      {:error, reason} ->
-        do_terminate(handler, {:error, reason}, event, name, reason)
-        :error
-    end
-  end
-
-  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
-    handler(ref: ref, id: id) = handler
-
-    receive do
-      {^ref, :ok} ->
-        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)
-        server_collect_process_handlers(mode, event, t, handlers, name)
-      {:DOWN, ^ref, _, _, reason} ->
-        do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
-        server_collect_process_handlers(mode, event, t, handlers, name)
-    end
-  end
-
-  defp server_collect_process_handlers(_mode, _event, [], handlers, _name) do
-    handlers
-  end
-
-  defp server_call(module, query, handlers, name) do
-    case :lists.keyfind(module, handler(:id) + 1, handlers) do
-      false ->
-        {false, {:error, :not_found}, handlers}
-      handler ->
-        case server_call_update(handler, query, name, handlers) do
-          {{hib, handler}, reply} ->
-            {hib, reply, :lists.keyreplace(module, handler(:id) + 1, handlers, handler)}
-          {:error, reply} ->
-            {false, reply, :lists.keydelete(module, handler(:id) + 1, handlers)}
-        end
-    end
-  end
-
-  defp server_call_update(handler, query, name, _handlers) do
-    handler(module: module, state: state) = handler
-    case do_handler(module, :handle_call, [query, state]) do
-      {:ok, res} ->
-        case res do
-          {:ok, reply, state} ->
-            {{false, handler(handler, state: state)}, reply}
-          {:ok, reply, state, :hibernate} ->
-            {{true, handler(handler, state: state)}, reply}
-          {:remove_handler, reply} ->
-            do_terminate(handler, :remove_handler, query, name, :normal)
-            {:error, reply}
-          other ->
-            reason = {:bad_return_value, other}
-            do_terminate(handler, {:error, reason}, query, name, reason)
-            {:error, {:error, reason}}
-        end
-      {:error, reason} ->
-        do_terminate(handler, {:error, reason}, query, name, reason)
-        {:error, {:error, reason}}
-    end
-  end
-
-  defp server_get_modules(handlers) do
-    (for handler(module: module) <- handlers, do: module)
-    |> :ordsets.from_list
-    |> :ordsets.to_list
-  end
-
-  defp server_which_handlers(handlers) do
-    for handler(id: id) <- handlers, do: id
-  end
-
-  defp server_terminate(reason, _parent, handlers, name) do
-    _ =
-      for handler <- handlers do
-        do_terminate(handler, :stop, :stop, name, :shutdown)
-      end
-    exit(reason)
-  end
-
-  defp reply({from, ref}, msg) do
-    send from, {ref, msg}
-  end
-
-  defp handle_down(ref, reason, handlers, name) do
-    case :lists.keyfind(ref, handler(:ref) + 1, handlers) do
-      false -> :error
-      handler ->
-        do_terminate(handler, {:stop, reason}, :DOWN, name, :shutdown)
-        {:ok, :lists.keydelete(ref, handler(:ref) + 1, handlers)}
-    end
-  end
-
-  defp do_add_handler(module, handler, arg, handlers, succ) do
-    case :lists.keyfind(handler(handler, :id), handler(:id) + 1, handlers) do
-      false ->
-        case do_handler(module, :init, [arg]) do
-          {:ok, res} ->
-            case res do
-              {:ok, state} ->
-                {false, succ, [handler(handler, state: state) | handlers]}
-              {:ok, state, :hibernate} ->
-                {true, succ, [handler(handler, state: state) | handlers]}
-              {:error, _} = error ->
-                {false, error, handlers}
-              other ->
-                {false, {:error, {:bad_return_value, other}}, handlers}
-            end
-          {:error, _} = error ->
-            {false, error, handlers}
-        end
-      _ ->
-        {false, {:error, :already_present}, handlers}
-    end
-  end
-
-  defp do_take_handler(module, args, handlers, name, last_in, reason) do
-    case :lists.keytake(module, handler(:id) + 1, handlers) do
-      {:value, handler, handlers} ->
-        {do_terminate(handler, args, last_in, name, reason), handlers}
-      false ->
-        {{:error, :not_found}, handlers}
-    end
-  end
-
-  defp do_terminate(handler, arg, last_in, name, reason) do
-    handler(module: module, state: state) = handler
-
-    res =
-      case do_handler(module, :terminate, [arg, state]) do
-        {:ok, res} -> res
-        {:error, _} = error -> error
-      end
-    report_terminate(handler, reason, state, last_in, name)
-    res
-  end
-
-  defp do_handler(mod, fun, args) do
-    try do
-      apply(mod, fun, args)
-    catch
-      :throw, val -> {:ok, val}
-      :error, val -> {:error, {val, System.stacktrace}}
-      :exit, val  -> {:error, val}
-    else
-      res -> {:ok, res}
-    end
-  end
-
-  defp report_terminate(handler, reason, state, last_in, name) do
-    report_error(handler, reason, state, last_in, name)
-    if ref = handler(handler, :ref) do
-      Process.demonitor(ref, [:flush])
-    end
-    if pid = handler(handler, :pid) do
-      send pid, {:gen_event_EXIT, handler(handler, :id), reason}
-    end
-  end
-
-  defp report_error(_handler, :normal, _, _, _), do: :ok
-  defp report_error(_handler, :shutdown, _, _, _), do: :ok
-  defp report_error(_handler, {:swapped, _, _}, _, _, _), do: :ok
-  defp report_error(handler, reason, state, last_in, name) do
-    reason =
-      case reason do
-        {:undef, [{m, f, a, _} | _] = mfas} ->
-          cond do
-            :code.is_loaded(m) === false ->
-              {:"module could not be loaded", mfas}
-            function_exported?(m, f, length(a)) ->
-              reason
-            true ->
-              {:"function not exported", mfas}
-          end
-        _ ->
-          reason
-      end
-
-    formatted = report_status(handler, state)
-
-    :error_logger.error_msg(
-      '** gen_event handler ~p crashed.~n' ++
-      '** Was installed in ~p~n' ++
-      '** Last event was: ~p~n' ++
-      '** When handler state == ~p~n' ++
-      '** Reason == ~p~n', [handler(handler, :id), name, last_in, formatted, reason])
-  end
-
-  defp report_status(handler(module: module), state) do
-    if function_exported?(module, :format_status, 2) do
-      try do
-        module.format_status(:terminate, [Process.get(), state])
-      catch
-        _, _ -> state
-      end
-    else
-      state
-    end
-  end
-end

lib/elixir/lib/gen_event/stream.ex

@@ -1,162 +0,0 @@
-defmodule GenEvent.Stream do
-  @moduledoc false
-  defstruct manager: nil, timeout: :infinity
-
-  @type t :: %__MODULE__{
-               manager: GenEvent.manager,
-               timeout: timeout}
-
-  @doc false
-  def init({_pid, _ref} = state) do
-    {:ok, state}
-  end
-
-  @doc false
-  def handle_event(event, _state) do
-    # 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
-    end
-  end
-
-  @doc false
-  def handle_call(msg, _state) do
-    # We do this to trick Dialyzer to not complain about non-local returns.
-    reason = {:bad_call, msg}
-    case :erlang.phash2(1, 1) do
-      0 -> exit(reason)
-      1 -> {:remove_handler, reason}
-    end
-  end
-
-  @doc false
-  def handle_info(_msg, state) do
-    {:ok, state}
-  end
-
-  @doc false
-  def terminate(_reason, _state) do
-    :ok
-  end
-
-  @doc false
-  def code_change(_old, state, _extra) do
-    {:ok, state}
-  end
-end
-
-defimpl Enumerable, for: GenEvent.Stream do
-  def reduce(stream, acc, fun) do
-    start_fun = fn() -> start(stream) end
-    next_fun = &next(stream, &1)
-    stop_fun = &stop(stream, &1)
-    Stream.resource(start_fun, next_fun, stop_fun).(acc, wrap_reducer(fun))
-  end
-
-  def count(_stream) do
-    {:error, __MODULE__}
-  end
-
-  def member?(_stream, _item) do
-    {:error, __MODULE__}
-  end
-
-  defp wrap_reducer(fun) do
-    fn
-      {:ack, manager, ref, event}, acc ->
-        send manager, {ref, :ok}
-        fun.(event, acc)
-      {:async, _manager, _ref, event}, acc ->
-        fun.(event, acc)
-      {:sync, manager, ref, event}, acc ->
-        try do
-          fun.(event, acc)
-        after
-          send manager, {ref, :ok}
-        end
-    end
-  end
-
-  defp start(%{manager: manager} = stream) do
-    try do
-      {:ok, {pid, ref}} = :gen.call(manager, self(),
-                                    {:add_process_handler, self(), self()}, :infinity)
-      mon_ref = Process.monitor(pid)
-      {pid, ref, mon_ref}
-    catch
-      :exit, reason -> exit({reason, {__MODULE__, :start, [stream]}})
-    end
-  end
-
-  defp next(%{timeout: timeout} = stream, {pid, ref, mon_ref} = acc) do
-    self = self()
-
-    receive do
-      # Got an async event.
-      {_from, {^pid, ^ref}, {:notify, event}} ->
-        {[{:async, pid, ref, event}], acc}
-
-      # Got a sync event.
-      {_from, {^pid, ^ref}, {:sync_notify, event}} ->
-        {[{:sync, pid, ref, event}], acc}
-
-      # Got an ack event.
-      {_from, {^pid, ^ref}, {:ack_notify, event}} ->
-        {[{:ack, pid, ref, event}], acc}
-
-      # The handler was removed. Stop iteration, resolve the
-      # event later. We need to demonitor now, otherwise DOWN
-      # appears with higher priority in the shutdown process.
-      {:gen_event_EXIT, {^pid, ^ref}, _reason} = event ->
-        Process.demonitor(mon_ref, [:flush])
-        send(self, event)
-        {:halt, {:removed, acc}}
-
-      # The manager died. Stop iteration, resolve the event later.
-      {:DOWN, ^mon_ref, _, _, _} = event ->
-        send(self, event)
-        {:halt, {:removed, acc}}
-    after
-      timeout ->
-        exit({:timeout, {__MODULE__, :next, [stream, acc]}})
-    end
-  end
-
-  # If we reach this branch, we know the handler was already
-  # removed, so we don't trigger a request for doing so.
-  defp stop(stream, {:removed, {pid, ref, mon_ref} = acc}) do
-    case wait_for_handler_removal(pid, ref, mon_ref) do
-      :ok ->
-        flush_events(ref)
-      {:error, reason} ->
-        exit({reason, {__MODULE__, :stop, [stream, acc]}})
-    end
-  end
-
-  # If we reach this branch, the handler was not removed yet,
-  # so we trigger a request for doing so.
-  defp stop(stream, {pid, ref, _} = acc) do
-    _ = :gen_event.delete_handler(pid, {pid, ref}, :shutdown)
-    stop(stream, {:removed, acc})
-  end
-
-  defp wait_for_handler_removal(pid, ref, mon_ref) do
-    receive do
-      {:gen_event_EXIT, {^pid, ^ref}, _reason} ->
-        Process.demonitor(mon_ref, [:flush])
-        :ok
-      {:DOWN, ^mon_ref, _, _, reason} ->
-        {:error, reason}
-    end
-  end
-
-  defp flush_events(ref) do
-    receive do
-      {_from, {_pid, ^ref}, {notify, _event}} when notify in [:notify, :ack_notify, :sync_notify] ->
-        flush_events(ref)
-    after
-      0 -> :ok
-    end
-  end
-end

lib/elixir/lib/gen_server.ex

@@ -1,972 +0,0 @@
-defmodule GenServer do
-  @moduledoc """
-  A behaviour module for implementing the server of a client-server relation.
-
-  A GenServer is a process like any other Elixir process and it can be used
-  to keep state, execute code asynchronously and so on. The advantage of using
-  a generic server process (GenServer) implemented using this module is that it
-  will have a standard set of interface functions and include functionality for
-  tracing and error reporting. It will also fit into a supervision tree.
-
-  ## Example
-
-  The GenServer behaviour abstracts the common client-server interaction.
-  Developers are only required to implement the callbacks and functionality
-  they are interested in.
-
-  Let's start with a code example and then explore the available callbacks.
-  Imagine we want a GenServer that works like a stack, allowing us to push
-  and pop items:
-
-      defmodule Stack do
-        use GenServer
-
-        # Callbacks
-
-        def handle_call(:pop, _from, [h | t]) do
-          {:reply, h, t}
-        end
-
-        def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
-        end
-      end
-
-      # Start the server
-      {:ok, pid} = GenServer.start_link(Stack, [:hello])
-
-      # This is the client
-      GenServer.call(pid, :pop)
-      #=> :hello
-
-      GenServer.cast(pid, {:push, :world})
-      #=> :ok
-
-      GenServer.call(pid, :pop)
-      #=> :world
-
-  We start our `Stack` by calling `start_link/3`, passing the module
-  with the server implementation and its initial argument (a list
-  representing the stack containing the item `:hello`). We can primarily
-  interact with the server by sending two types of messages. **call**
-  messages expect a reply from the server (and are therefore synchronous)
-  while **cast** messages do not.
-
-  Every time you do a `GenServer.call/3`, the client will send a message
-  that must be handled by the `c:handle_call/3` callback in the GenServer.
-  A `cast/2` message must be handled by `c:handle_cast/2`.
-
-  ## use GenServer and callbacks
-
-  There are 6 callbacks required to be implemented in a `GenServer`. By
-  adding `use GenServer` to your module, Elixir will automatically define
-  all 6 callbacks for you, leaving it up to you to implement the ones
-  you want to customize.
-
-  `use GenServer` also defines a `child_spec/1` function, allowing the
-  defined module to be put under a supervision tree. The generated
-  `child_spec/1` can be customized with the following options:
-
-    * `:id` - the child specification id, defauts to the current module
-    * `:start` - how to start the child process (defaults to calling `__MODULE__.start_link/1`)
-    * `:restart` - when the child should be restarted, defaults to `:permanent`
-    * `:shutdown` - how to shut down the child
-
-  For example:
-
-      use GenServer, restart: :transient, shutdown: 10_000
-
-  See the `Supervisor` docs for more information.
-
-  ## Name Registration
-
-  Both `start_link/3` and `start/3` support the `GenServer` to register
-  a name on start via the `:name` option. Registered names are also
-  automatically cleaned up on termination. The supported values are:
-
-    * an atom - the GenServer is registered locally with the given name
-      using `Process.register/2`.
-
-    * `{:global, term}`- the GenServer is registered globally with the given
-      term using the functions in the [`:global` module](http://www.erlang.org/doc/man/global.html).
-
-    * `{:via, module, term}` - the GenServer is registered with the given
-      mechanism and name. The `:via` option expects a module that exports
-      `register_name/2`, `unregister_name/1`, `whereis_name/1` and `send/2`.
-      One such example is the [`:global` module](http://www.erlang.org/doc/man/global.html) which uses these functions
-      for keeping the list of names of processes and their associated PIDs
-      that are available globally for a network of Elixir nodes. Elixir also
-      ships with a local, decentralized and scalable registry called `Registry`
-      for locally storing names that are generated dynamically.
-
-  For example, we could start and register our `Stack` server locally as follows:
-
-      # Start the server and register it locally with name MyStack
-      {:ok, _} = GenServer.start_link(Stack, [:hello], name: MyStack)
-
-      # Now messages can be sent directly to MyStack
-      GenServer.call(MyStack, :pop) #=> :hello
-
-  Once the server is started, the remaining functions in this module (`call/3`,
-  `cast/2`, and friends) will also accept an atom, or any `:global` or `:via`
-  tuples. In general, the following formats are supported:
-
-    * a `pid`
-    * an `atom` if the server is locally registered
-    * `{atom, node}` if the server is locally registered at another node
-    * `{:global, term}` if the server is globally registered
-    * `{:via, module, name}` if the server is registered through an alternative
-      registry
-
-  If there is an interest to register dynamic names locally, do not use
-  atoms, as atoms are never garbage collected and therefore dynamically
-  generated atoms won't be garbage collected. For such cases, you can
-  set up your own local registry by using the `Registry` module.
-
-  ## Client / Server APIs
-
-  Although in the example above we have used `GenServer.start_link/3` and
-  friends to directly start and communicate with the server, most of the
-  time we don't call the `GenServer` functions directly. Instead, we wrap
-  the calls in new functions representing the public API of the server.
-
-  Here is a better implementation of our Stack module:
-
-      defmodule Stack do
-        use GenServer
-
-        # Client
-
-        def start_link(default) do
-          GenServer.start_link(__MODULE__, default)
-        end
-
-        def push(pid, item) do
-          GenServer.cast(pid, {:push, item})
-        end
-
-        def pop(pid) do
-          GenServer.call(pid, :pop)
-        end
-
-        # Server (callbacks)
-
-        def handle_call(:pop, _from, [h | t]) do
-          {:reply, h, t}
-        end
-
-        def handle_call(request, from, state) do
-          # Call the default implementation from GenServer
-          super(request, from, state)
-        end
-
-        def handle_cast({:push, item}, state) do
-          {:noreply, [item | state]}
-        end
-
-        def handle_cast(request, state) do
-          super(request, state)
-        end
-      end
-
-  In practice, it is common to have both server and client functions in
-  the same module. If the server and/or client implementations are growing
-  complex, you may want to have them in different modules.
-
-  ## Receiving "regular" messages
-
-  The goal of a `GenServer` is to abstract the "receive" loop for developers,
-  automatically handling system messages, support code change, synchronous
-  calls and more. Therefore, you should never call your own "receive" inside
-  the GenServer callbacks as doing so will cause the GenServer to misbehave.
-
-  Besides the synchronous and asynchronous communication provided by `call/3`
-  and `cast/2`, "regular" messages sent by functions such `Kernel.send/2`,
-  `Process.send_after/4` and similar, can be handled inside the `c:handle_info/2`
-  callback.
-
-  `c:handle_info/2` can be used in many situations, such as handling monitor
-  DOWN messages sent by `Process.monitor/1`. Another use case for `c:handle_info/2`
-  is to perform periodic work, with the help of `Process.send_after/4`:
-
-      defmodule MyApp.Periodically do
-        use GenServer
-
-        def start_link do
-          GenServer.start_link(__MODULE__, %{})
-        end
-
-        def init(state) do
-          schedule_work() # Schedule work to be performed on start
-          {:ok, state}
-        end
-
-        def handle_info(:work, state) do
-          # Do the desired work here
-          schedule_work() # Reschedule once more
-          {:noreply, state}
-        end
-
-        defp schedule_work() do
-          Process.send_after(self(), :work, 2 * 60 * 60 * 1000) # In 2 hours
-        end
-      end
-
-  ## Debugging with the :sys module
-
-  GenServers, as [special processes](http://erlang.org/doc/design_principles/spec_proc.html),
-  can be debugged using the [`:sys` module](http://www.erlang.org/doc/man/sys.html). Through various hooks, this module
-  allows developers to introspect the state of the process and trace
-  system events that happen during its execution, such as received messages,
-  sent replies and state changes.
-
-  Let's explore the basic functions from the [`:sys` module](http://www.erlang.org/doc/man/sys.html) used for debugging:
-
-    * [`:sys.get_state/2`](http://erlang.org/doc/man/sys.html#get_state-2) -
-      allows retrieval of the state of the process. In the case of
-      a GenServer process, it will be the callback module state, as
-      passed into the callback functions as last argument.
-    * [`:sys.get_status/2`](http://erlang.org/doc/man/sys.html#get_status-2) -
-      allows retrieval of the status of the process. This status includes
-      the process dictionary, if the process is running or is suspended,
-      the parent PID, the debugger state, and the state of the behaviour module,
-      which includes the callback module state (as returned by `:sys.get_state/2`).
-      It's possible to change how this status is represented by defining
-      the optional `c:GenServer.format_status/2` callback.
-    * [`:sys.trace/3`](http://erlang.org/doc/man/sys.html#trace-3) -
-      prints all the system events to `:stdio`.
-    * [`:sys.statistics/3`](http://erlang.org/doc/man/sys.html#statistics-3) -
-      manages collection of process statistics.
-    * [`:sys.no_debug/2`](http://erlang.org/doc/man/sys.html#no_debug-2) -
-      turns off all debug handlers for the given process. It is very important
-      to switch off debugging once we're done. Excessive debug handlers or
-      those that should be turned off, but weren't, can seriously damage
-      the performance of the system.
-    * [`:sys.suspend/2`](http://erlang.org/doc/man/sys.html#suspend-2) - allows
-      to suspend a process so that it only replies to system messages but no
-      other messages. A suspended process can be reactivated via
-      [`:sys.resume/2`](http://erlang.org/doc/man/sys.html#resume-2).
-
-  Let's see how we could use those functions for debugging the stack server
-  we defined earlier.
-
-      iex> {:ok, pid} = Stack.start_link([])
-      iex> :sys.statistics(pid, true) # turn on collecting process statistics
-      iex> :sys.trace(pid, true) # turn on event printing
-      iex> Stack.push(pid, 1)
-      *DBG* <0.122.0> got cast {push,1}
-      *DBG* <0.122.0> new state [1]
-      :ok
-      iex> :sys.get_state(pid)
-      [1]
-      iex> Stack.pop(pid)
-      *DBG* <0.122.0> got call pop from <0.80.0>
-      *DBG* <0.122.0> sent 1 to <0.80.0>, new state []
-      1
-      iex> :sys.statistics(pid, :get)
-      {:ok,
-       [start_time: {{2016, 7, 16}, {12, 29, 41}},
-        current_time: {{2016, 7, 16}, {12, 29, 50}},
-        reductions: 117, messages_in: 2, messages_out: 0]}
-      iex> :sys.no_debug(pid) # turn off all debug handlers
-      :ok
-      iex> :sys.get_status(pid)
-      {:status, #PID<0.122.0>, {:module, :gen_server},
-       [["$initial_call": {Stack, :init, 1},            # pdict
-         "$ancestors": [#PID<0.80.0>, #PID<0.51.0>]],
-        :running,                                       # :running | :suspended
-        #PID<0.80.0>,                                   # parent
-        [],                                             # debugger state
-        [header: 'Status for generic server <0.122.0>', # module status
-         data: [{'Status', :running}, {'Parent', #PID<0.80.0>},
-           {'Logged events', []}], data: [{'State', [1]}]]]}
-
-  ## Learn more
-
-  If you wish to find out more about gen servers, the Elixir Getting Started
-  guide provides a tutorial-like introduction. The documentation and links
-  in Erlang can also provide extra insight.
-
-    * [GenServer – Elixir's Getting Started Guide](http://elixir-lang.org/getting-started/mix-otp/genserver.html)
-    * [`:gen_server` module documentation](http://www.erlang.org/doc/man/gen_server.html)
-    * [gen_server Behaviour – OTP Design Principles](http://www.erlang.org/doc/design_principles/gen_server_concepts.html)
-    * [Clients and Servers – Learn You Some Erlang for Great Good!](http://learnyousomeerlang.com/clients-and-servers)
-  """
-
-  @doc """
-  Invoked when the server is started. `start_link/3` or `start/3` will
-  block until it returns.
-
-  `args` is the argument term (second argument) passed to `start_link/3`.
-
-  Returning `{:ok, state}` will cause `start_link/3` to return
-  `{:ok, pid}` and the process to enter its loop.
-
-  Returning `{:ok, state, timeout}` is similar to `{:ok, state}`
-  except `handle_info(:timeout, state)` will be called after `timeout`
-  milliseconds if no messages are received within the timeout.
-
-  Returning `{:ok, state, :hibernate}` is similar to
-  `{:ok, state}` except the process is hibernated before entering the loop. See
-  `c:handle_call/3` for more information on hibernation.
-
-  Returning `:ignore` will cause `start_link/3` to return `:ignore` and the
-  process will exit normally without entering the loop or calling `c:terminate/2`.
-  If used when part of a supervision tree the parent supervisor will not fail
-  to start nor immediately try to restart the `GenServer`. The remainder of the
-  supervision tree will be (re)started and so the `GenServer` should not be
-  required by other processes. It can be started later with
-  `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.
-
-  Returning `{:stop, reason}` will cause `start_link/3` to return
-  `{:error, reason}` and the process to exit with reason `reason` without
-  entering the loop or calling `c:terminate/2`.
-  """
-  @callback init(args :: term) ::
-    {:ok, state} |
-    {:ok, state, timeout | :hibernate} |
-    :ignore |
-    {:stop, reason :: any} when state: any
-
-  @doc """
-  Invoked to handle synchronous `call/3` messages. `call/3` will block until a
-  reply is received (unless the call times out or nodes are disconnected).
-
-  `request` is the request message sent by a `call/3`, `from` is a 2-tuple
-  containing the caller's PID and a term that uniquely identifies the call, and
-  `state` is the current state of the `GenServer`.
-
-  Returning `{:reply, reply, new_state}` sends the response `reply` to the
-  caller and continues the loop with new state `new_state`.
-
-  Returning `{:reply, reply, new_state, timeout}` is similar to
-  `{:reply, reply, new_state}` except `handle_info(:timeout, new_state)` will be
-  called after `timeout` milliseconds if no messages are received.
-
-  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.
-
-  Hibernating should not be used aggressively as too much time could be spent
-  garbage collecting. Normally it should only be used when a message is not
-  expected soon and minimising the memory of the process is shown to be
-  beneficial.
-
-  Returning `{:noreply, new_state}` does not send a response to the caller and
-  continues the loop with new state `new_state`. The response must be sent with
-  `reply/2`.
-
-  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.
-
-  When replying from another process the `GenServer` should exit if the other
-  process exits without replying as the caller will be blocking awaiting a
-  reply.
-
-  Returning `{:noreply, new_state, timeout | :hibernate}` is similar to
-  `{:noreply, new_state}` except a timeout or hibernation occurs as with a
-  `:reply` tuple.
-
-  Returning `{:stop, reason, reply, new_state}` stops the loop and `c:terminate/2`
-  is called with reason `reason` and state `new_state`. Then the `reply` is sent
-  as the response to call and the process exits with reason `reason`.
-
-  Returning `{:stop, reason, new_state}` is similar to
-  `{:stop, reason, reply, new_state}` except a reply is not sent.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:stop, {:bad_call, request}, state}`.
-  """
-  @callback handle_call(request :: term, from, state :: term) ::
-    {:reply, reply, new_state} |
-    {:reply, reply, new_state, timeout | :hibernate} |
-    {:noreply, new_state} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason, reply, new_state} |
-    {:stop, reason, new_state} when reply: term, new_state: term, reason: term
-
-  @doc """
-  Invoked to handle asynchronous `cast/2` messages.
-
-  `request` is the request message sent by a `cast/2` and `state` is the current
-  state of the `GenServer`.
-
-  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.
-
-  Returning `{:noreply, new_state, :hibernate}` is similar to
-  `{:noreply, new_state}` except the process is hibernated before continuing the
-  loop. See `c:handle_call/3` for more information.
-
-  Returning `{:stop, reason, new_state}` stops the loop and `c: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} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason :: term, new_state} when new_state: term
-
-  @doc """
-  Invoked to handle all other messages.
-
-  `msg` is the message and `state` is the current state of the `GenServer`. When
-  a timeout occurs the message is `:timeout`.
-
-  Return values are the same as `c:handle_cast/2`.
-
-  If this callback is not implemented, the default implementation by
-  `use GenServer` will return `{:noreply, state}`.
-  """
-  @callback handle_info(msg :: :timeout | term, state :: term) ::
-    {:noreply, new_state} |
-    {:noreply, new_state, timeout | :hibernate} |
-    {:stop, reason :: term, new_state} when new_state: term
-
-  @doc """
-  Invoked when the server is about to exit. It should do any cleanup required.
-
-  `reason` is exit reason and `state` is the current state of the `GenServer`.
-  The return value is ignored.
-
-  `c:terminate/2` is called if a callback (except `c:init/1`) does one of the
-  following:
-
-    * returns a `:stop` tuple
-    * raises
-    * calls `Kernel.exit/1`
-    * returns an invalid value
-    * the `GenServer` traps exits (using `Process.flag/2`) *and* the parent
-      process sends an exit signal
-
-  If part of a supervision tree, a `GenServer`'s `Supervisor` will send an exit
-  signal when shutting it down. The exit signal is based on the shutdown
-  strategy in the child's specification. If it is `:brutal_kill` the `GenServer`
-  is killed and so `c:terminate/2` is not called. However if it is a timeout the
-  `Supervisor` will send the exit signal `:shutdown` and the `GenServer` will
-  have the duration of the timeout to call `c:terminate/2` - if the process is
-  still alive after the timeout it is killed.
-
-  If the `GenServer` receives an exit signal (that is not `:normal`) from any
-  process when it is not trapping exits it will exit abruptly with the same
-  reason and so not call `c:terminate/2`. Note that a process does *NOT* trap
-  exits by default and an exit signal is sent when a linked process exits or its
-  node is disconnected.
-
-  Therefore it is not guaranteed that `c:terminate/2` is called when a `GenServer`
-  exits. For such reasons, we usually recommend important clean-up rules to
-  happen in separated processes either by use of monitoring or by links
-  themselves. For example if the `GenServer` controls a `port` (e.g.
-  `:gen_tcp.socket`) or `t:File.io_device/0`, they will be closed on receiving a
-  `GenServer`'s exit signal and do not need to be closed in `c:terminate/2`.
-
-  If `reason` is not `:normal`, `:shutdown`, nor `{:shutdown, term}` an error is
-  logged.
-  """
-  @callback terminate(reason, state :: term) ::
-    term when reason: :normal | :shutdown | {:shutdown, term} | term
-
-  @doc """
-  Invoked to change the state of the `GenServer` when a different version of a
-  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
-  `GenServer` 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.
-
-  Returning `{:error, reason}` fails the code change with reason `reason` and
-  the state remains as the previous state.
-
-  If `c:code_change/3` raises the code change fails and the loop will continue
-  with its previous state. Therefore this callback does not usually contain side effects.
-  """
-  @callback code_change(old_vsn, state :: term, extra :: term) ::
-    {:ok, new_state :: term} |
-    {:error, reason :: term} when old_vsn: term | {:down, term}
-
-  @doc """
-  Invoked in some cases to retrieve a formatted version of the `GenServer` status.
-
-  This callback can be useful to control the *appearance* of the status of the
-  `GenServer`. For example, it can be used to return a compact representation of
-  the `GenServer`'s state to avoid having large state terms printed.
-
-    * one of `:sys.get_status/1` or `:sys.get_status/2` is invoked to get the
-      status of the `GenServer`; in such cases, `reason` is `:normal`
-
-    * the `GenServer` terminates abnormally and logs an error; in such cases,
-      `reason` is `:terminate`
-
-  `pdict_and_state` is a two-elements list `[pdict, state]` where `pdict` is a
-  list of `{key, value}` tuples representing the current process dictionary of
-  the `GenServer` and `state` is the current state of the `GenServer`.
-  """
-  @callback format_status(reason, pdict_and_state :: list) ::
-    term when reason: :normal | :terminate
-
-  @optional_callbacks format_status: 2
-
-  @typedoc "Return values of `start*` functions"
-  @type on_start :: {:ok, pid} | :ignore | {:error, {:already_started, pid} | term}
-
-  @typedoc "The GenServer name"
-  @type name :: atom | {:global, term} | {:via, module, term}
-
-  @typedoc "Options used by the `start*` functions"
-  @type options :: [option]
-
-  @typedoc "Option values used by the `start*` functions"
-  @type option :: {:debug, debug} |
-                  {:name, name} |
-                  {:timeout, timeout} |
-                  {:spawn_opt, Process.spawn_opt}
-
-  @typedoc "Debug options supported by the `start*` functions"
-  @type debug :: [:trace | :log | :statistics | {:log_to_file, Path.t}]
-
-  @typedoc "The server reference"
-  @type server :: pid | name | {atom, node}
-
-  @typedoc """
-  Tuple describing the client of a call request.
-
-  `pid` is the PID of the caller and `tag` is a unique term used to identify the
-  call.
-  """
-  @type from :: {pid, tag :: term}
-
-  @doc false
-  defmacro __using__(opts) do
-    quote location: :keep, bind_quoted: [opts: opts] do
-      @behaviour GenServer
-
-      spec = [
-        id: opts[:id] || __MODULE__,
-        start: Macro.escape(opts[:start]) || quote(do: {__MODULE__, :start_link, [arg]}),
-        restart: opts[:restart] || :permanent,
-        shutdown: opts[:shutdown] || 5000,
-        type: :worker
-      ]
-
-      @doc false
-      def child_spec(arg) do
-        %{unquote_splicing(spec)}
-      end
-
-      defoverridable child_spec: 1
-
-      @doc false
-      def init(args) do
-        {:ok, args}
-      end
-
-      @doc false
-      def handle_call(msg, _from, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to call GenServer #{inspect proc} but no handle_call/3 clause was provided"
-          1 -> {:stop, {:bad_call, msg}, state}
-        end
-      end
-
-      @doc false
-      def handle_info(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-        :error_logger.error_msg('~p ~p received unexpected message in handle_info/2: ~p~n',
-                                [__MODULE__, proc, msg])
-        {:noreply, state}
-      end
-
-      @doc false
-      def handle_cast(msg, state) do
-        proc =
-          case Process.info(self(), :registered_name) do
-            {_, []}   -> self()
-            {_, name} -> name
-          end
-
-        # We do this to trick Dialyzer to not complain about non-local returns.
-        case :erlang.phash2(1, 1) do
-          0 -> raise "attempted to cast GenServer #{inspect proc} but no handle_cast/2 clause was provided"
-          1 -> {:stop, {:bad_cast, msg}, state}
-        end
-      end
-
-      @doc false
-      def terminate(_reason, _state) do
-        :ok
-      end
-
-      @doc false
-      def code_change(_old, state, _extra) do
-        {:ok, state}
-      end
-
-      defoverridable GenServer
-    end
-  end
-
-  @doc """
-  Starts a `GenServer` process linked to the current process.
-
-  This is often used to start the `GenServer` as part of a supervision tree.
-
-  Once the server is started, the `c:init/1` function of the given `module` is
-  called with `args` as its arguments to initialize the server. To ensure a
-  synchronized start-up procedure, this function does not return until `c:init/1`
-  has returned.
-
-  Note that a `GenServer` started with `start_link/3` is linked to the
-  parent process and will exit in case of crashes from the parent. The GenServer
-  will also exit due to the `:normal` reasons in case it is configured to trap
-  exits in the `c:init/1` callback.
-
-  ## Options
-
-    * `:name` - used for name registration as described in the "Name
-      registration" section of the module documentation
-
-    * `: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}`
-
-    * `: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`
-
-  ## Return values
-
-  If the server is successfully created and initialized, this function returns
-  `{:ok, pid}`, where `pid` is the PID of the server. If a process with the
-  specified server name already exists, this function returns
-  `{:error, {:already_started, pid}}` with the PID of that process.
-
-  If the `c:init/1` callback fails with `reason`, this function returns
-  `{:error, reason}`. Otherwise, if it returns `{:stop, reason}`
-  or `:ignore`, the process is terminated and this function returns
-  `{:error, reason}` or `:ignore`, respectively.
-  """
-  @spec start_link(module, any, options) :: on_start
-  def start_link(module, args, options \\ []) when is_atom(module) and is_list(options) do
-    do_start(:link, module, args, options)
-  end
-
-  @doc """
-  Starts a `GenServer` process without links (outside of a supervision tree).
-
-  See `start_link/3` for more information.
-  """
-  @spec start(module, any, options) :: on_start
-  def start(module, args, options \\ []) when is_atom(module) and is_list(options) do
-    do_start(:nolink, module, args, options)
-  end
-
-  defp do_start(link, module, args, options) do
-    case Keyword.pop(options, :name) do
-      {nil, opts} ->
-        :gen.start(:gen_server, link, module, args, opts)
-      {atom, opts} when is_atom(atom) ->
-        :gen.start(:gen_server, link, {:local, atom}, module, args, opts)
-      {{:global, _term} = tuple, opts} ->
-        :gen.start(:gen_server, link, tuple, module, args, opts)
-      {{:via, via_module, _term} = tuple, opts} when is_atom(via_module) ->
-        :gen.start(:gen_server, link, tuple, module, args, opts)
-      {other, _} ->
-        raise ArgumentError, """
-        expected :name option to be one of:
-
-          * nil
-          * atom
-          * {:global, term}
-          * {:via, module, term}
-
-        Got: #{inspect(other)}
-        """
-    end
-  end
-
-  @doc """
-  Synchronously stops the server with the given `reason`.
-
-  The `c:terminate/2` callback of the given `server` will be invoked before
-  exiting. This function returns `:ok` if the server terminates with the
-  given reason; if it terminates with another reason, the call exits.
-
-  This function keeps OTP semantics regarding error reporting.
-  If the reason is any other than `:normal`, `:shutdown` or
-  `{:shutdown, _}`, an error report is logged.
-  """
-  @spec stop(server, reason :: term, timeout) :: :ok
-  def stop(server, reason \\ :normal, timeout \\ :infinity) do
-    :gen.stop(server, reason, timeout)
-  end
-
-  @doc """
-  Makes a synchronous call to the `server` and waits for its reply.
-
-  The client sends the given `request` to the server and waits until a reply
-  arrives or a timeout occurs. `c:handle_call/3` will be called on the server
-  to handle the request.
-
-  `server` can be any of the values described in the "Name registration"
-  section of the documentation for this module.
-
-  ## Timeouts
-
-  `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.
-  """
-  @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
-    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
-  is unknown whether the destination `server` successfully
-  handled the message.
-
-  `c:handle_cast/2` will be called on the server to handle
-  the request. In case the `server` is on a node which is
-  not yet connected to the caller one, the call is going to
-  block until a connection happens. This is different than
-  the behaviour in OTP's `:gen_server` where the message
-  is sent by another process in this case, which could cause
-  messages to other nodes to arrive out of order.
-  """
-  @spec cast(server, term) :: :ok
-  def cast(server, request)
-
-  def cast({:global, name}, request) do
-    try do
-      :global.send(name, cast_msg(request))
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  end
-
-  def cast({:via, mod, name}, request) do
-    try do
-      mod.send(name, cast_msg(request))
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  end
-
-  def cast({name, node}, request) when is_atom(name) and is_atom(node),
-    do: do_send({name, node}, cast_msg(request))
-
-  def cast(dest, request) when is_atom(dest) or is_pid(dest),
-    do: do_send(dest, cast_msg(request))
-
-  @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
-  server name does not exist.
-
-  See `multi_call/4` for more information.
-  """
-  @spec abcast([node], name :: atom, term) :: :abcast
-  def abcast(nodes \\ [node() | Node.list()], name, request) when is_list(nodes) and is_atom(name) do
-    msg = cast_msg(request)
-    _   = for node <- nodes, do: do_send({name, node}, msg)
-    :abcast
-  end
-
-  defp cast_msg(req) do
-    {:"$gen_cast", req}
-  end
-
-  defp do_send(dest, msg) do
-    try do
-      send(dest, msg)
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  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:
-
-    * `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).
-
-  To avoid that late answers (after the timeout) pollute the caller's message
-  queue, a middleman process is used to do the actual calls. Late answers will
-  then be discarded when they arrive to a terminated process.
-
-  ## Examples
-
-  Assuming the `Stack` GenServer mentioned in the docs for the `GenServer`
-  module is registered as `Stack` in the `:"foo@my-machine"` and
-  `:"bar@my-machine"` nodes:
-
-      GenServer.multi_call(Stack, :pop)
-      #=> {[{:"foo@my-machine", :hello}, {:"bar@my-machine", :world}], []}
-
-  """
-  @spec multi_call([node], name :: atom, term, timeout) ::
-                  {replies :: [{node, term}], bad_nodes :: [node]}
-  def multi_call(nodes \\ [node() | Node.list()], name, request, timeout \\ :infinity) do
-    :gen_server.multi_call(nodes, name, request, timeout)
-  end
-
-  @doc """
-  Replies to a client.
-
-  This function can be used to explicitly send a reply to a client that called
-  `call/3` or `multi_call/4` when the reply cannot be specified in the return
-  value of `c:handle_call/3`.
-
-  `client` must be the `from` argument (the second argument) accepted by
-  `c:handle_call/3` callbacks. `reply` is an arbitrary term which will be given
-  back to the client as the return value of the call.
-
-  Note that `reply/2` can be called from any process, not just the GenServer
-  that originally received the call (as long as that GenServer communicated the
-  `from` argument somehow).
-
-  This function always returns `:ok`.
-
-  ## Examples
-
-      def handle_call(:reply_in_one_second, from, state) do
-        Process.send_after(self(), {:reply, from}, 1_000)
-        {:noreply, state}
-      end
-
-      def handle_info({:reply, from}, state) do
-        GenServer.reply(from, :one_second_has_passed)
-        {:noreply, state}
-      end
-
-  """
-  @spec reply(from, term) :: :ok
-  def reply(client, reply)
-
-  def reply({to, tag}, reply) when is_pid(to) do
-    try do
-      send(to, {tag, reply})
-      :ok
-    catch
-      _, _ -> :ok
-    end
-  end
-
-  @doc """
-  Returns the `pid` or `{name, node}` of a GenServer process, or `nil` if
-  no process is associated with the given `server`.
-
-  ## Examples
-
-  For example, to lookup a server process, monitor it and send a cast to it:
-
-      process = GenServer.whereis(server)
-      monitor = Process.monitor(process)
-      GenServer.cast(process, :hello)
-
-  """
-  @spec whereis(server) :: pid | {atom, node} | nil
-  def whereis(server)
-
-  def whereis(pid) when is_pid(pid), do: pid
-
-  def whereis(name) when is_atom(name) do
-    Process.whereis(name)
-  end
-
-  def whereis({:global, name}) do
-    case :global.whereis_name(name) do
-      pid when is_pid(pid) -> pid
-      :undefined           -> nil
-    end
-  end
-
-  def whereis({:via, mod, name}) do
-    case apply(mod, :whereis_name, [name]) do
-      pid when is_pid(pid) -> pid
-      :undefined           -> nil
-    end
-  end
-
-  def whereis({name, local}) when is_atom(name) and local == node() do
-    Process.whereis(name)
-  end
-
-  def whereis({name, node} = server) when is_atom(name) and is_atom(node) do
-    server
-  end
-end

lib/elixir/lib/hash_dict.ex

@@ -1,267 +0,0 @@
-defmodule HashDict do
-  @moduledoc """
-  WARNING: this module is deprecated.
-
-  Use the `Map` module instead.
-  """
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-
-  use Dict
-
-  @node_bitmap 0b111
-  @node_shift 3
-  @node_size 8
-  @node_template :erlang.make_tuple(@node_size, [])
-
-  @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
-  @doc false
-  defstruct size: 0, root: @node_template
-
-  # Inline common instructions
-  @compile :inline_list_funcs
-  @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
-
-  @doc """
-  Creates a new empty dict.
-  """
-  @spec new :: Dict.t
-  def new do
-    %HashDict{}
-  end
-
-  def put(%HashDict{root: root, size: size}, key, value) do
-    {root, counter} = do_put(root, key, value, key_hash(key))
-    %HashDict{root: root, size: size + counter}
-  end
-
-  def update!(%HashDict{root: root, size: size} = dict, key, fun) when is_function(fun, 1) do
-    {root, counter} = do_update(root, key, fn -> raise KeyError, key: key, term: dict end,
-                                fun, key_hash(key))
-    %HashDict{root: root, size: size + counter}
-  end
-
-  def update(%HashDict{root: root, size: size}, key, initial, fun) when is_function(fun, 1) do
-    {root, counter} = do_update(root, key, fn -> initial end, fun, key_hash(key))
-    %HashDict{root: root, size: size + counter}
-  end
-
-  def fetch(%HashDict{root: root}, key) do
-    do_fetch(root, key, key_hash(key))
-  end
-
-  def delete(dict, key) do
-    case dict_delete(dict, key) do
-      {dict, _value} -> dict
-      :error         -> dict
-    end
-  end
-
-  def pop(dict, key, default \\ nil) do
-    case dict_delete(dict, key) do
-      {dict, value} -> {value, dict}
-      :error        -> {default, dict}
-    end
-  end
-
-  def size(%HashDict{size: size}) do
-    size
-  end
-
-  @doc false
-  def reduce(%HashDict{root: root}, acc, fun) do
-    do_reduce(root, acc, fun, @node_size, fn
-      {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc}    -> {:halted, acc}
-      {:cont, acc}    -> {:done, acc}
-    end)
-  end
-
-  ## General helpers
-
-  @doc false
-  def dict_delete(%HashDict{root: root, size: size}, key) do
-    case do_delete(root, key, key_hash(key)) do
-      {root, value} -> {%HashDict{root: root, size: size - 1}, value}
-      :error        -> :error
-    end
-  end
-
-  ## Dict manipulation
-
-  defp do_fetch(node, key, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [^key | v]   -> {:ok, v}
-      {^key, v, _} -> {:ok, v}
-      {_, _, n}    -> do_fetch(n, key, key_shift(hash))
-      _            -> :error
-    end
-  end
-
-  defp do_put(node, key, value, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [] ->
-        {put_elem(node, index, [key | value]), 1}
-      [^key | _] ->
-        {put_elem(node, index, [key | value]), 0}
-      [k | v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | value])
-        {put_elem(node, index, {k, v, n}), 1}
-      {^key, _, n} ->
-        {put_elem(node, index, {key, value, n}), 0}
-      {k, v, n} ->
-        {n, counter} = do_put(n, key, value, key_shift(hash))
-        {put_elem(node, index, {k, v, n}), counter}
-    end
-  end
-
-  defp do_update(node, key, initial, fun, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [] ->
-        {put_elem(node, index, [key | initial.()]), 1}
-      [^key | value] ->
-        {put_elem(node, index, [key | fun.(value)]), 0}
-      [k | v] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [key | initial.()])
-        {put_elem(node, index, {k, v, n}), 1}
-      {^key, value, n} ->
-        {put_elem(node, index, {key, fun.(value), n}), 0}
-      {k, v, n} ->
-        {n, counter} = do_update(n, key, initial, fun, key_shift(hash))
-        {put_elem(node, index, {k, v, n}), counter}
-    end
-  end
-
-  defp do_delete(node, key, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [] ->
-        :error
-      [^key | value] ->
-        {put_elem(node, index, []), value}
-      [_ | _] ->
-        :error
-      {^key, value, n} ->
-        {put_elem(node, index, do_compact_node(n)), value}
-      {k, v, n} ->
-        case do_delete(n, key, key_shift(hash)) do
-          {@node_template, value} ->
-            {put_elem(node, index, [k | v]), value}
-          {n, value} ->
-            {put_elem(node, index, {k, v, n}), value}
-          :error ->
-            :error
-        end
-    end
-  end
-
-  Enum.each 0..(@node_size - 1), fn index ->
-    defp do_compact_node(node) when elem(node, unquote(index)) != [] do
-      case elem(node, unquote(index)) do
-        [k | v] ->
-          case put_elem(node, unquote(index), []) do
-            @node_template -> [k | v]
-            n -> {k, v, n}
-          end
-        {k, v, n} ->
-          {k, v, put_elem(node, unquote(index), do_compact_node(n))}
-      end
-    end
-  end
-
-  ## Dict reduce
-
-  defp do_reduce_each(_node, {:halt, acc}, _fun, _next) do
-    {:halted, acc}
-  end
-
-  defp do_reduce_each(node, {:suspend, acc}, fun, next) do
-    {:suspended, acc, &do_reduce_each(node, &1, fun, next)}
-  end
-
-  defp do_reduce_each([], acc, _fun, next) do
-    next.(acc)
-  end
-
-  defp do_reduce_each([k | v], {:cont, acc}, fun, next) do
-    next.(fun.({k, v}, acc))
-  end
-
-  defp do_reduce_each({k, v, n}, {:cont, acc}, fun, next) do
-    do_reduce(n, fun.({k, v}, acc), fun, @node_size, next)
-  end
-
-  defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
-  end
-
-  defp do_reduce(_node, acc, _fun, 0, next) do
-    next.(acc)
-  end
-
-  ## Key operations
-
-  import Bitwise
-
-  defp key_hash(key) do
-    :erlang.phash2(key)
-  end
-
-  defp key_mask(hash) do
-    hash &&& @node_bitmap
-  end
-
-  defp key_shift(hash) do
-    hash >>> @node_shift
-  end
-end
-
-defimpl Enumerable, for: HashDict do
-  def reduce(dict, acc, fun) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    module.reduce(dict, acc, fun)
-  end
-
-  def member?(dict, {key, value}) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, match?({:ok, ^value}, module.fetch(dict, key))}
-  end
-
-  def member?(_dict, _) do
-    {:ok, false}
-  end
-
-  def count(dict) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {:ok, module.size(dict)}
-  end
-end
-
-defimpl Collectable, for: HashDict do
-  def into(original) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    {original, fn
-      dict, {:cont, {key, value}} -> module.put(dict, key, value)
-      dict, :done -> dict
-      _, :halt -> :ok
-    end}
-  end
-end
-
-defimpl Inspect, for: HashDict do
-  import Inspect.Algebra
-
-  def inspect(dict, opts) do
-    # Avoid warnings about HashDict being deprecated.
-    module = HashDict
-    concat ["#HashDict<", Inspect.List.inspect(module.to_list(dict), opts), ">"]
-  end
-end

lib/elixir/lib/hash_set.ex

@@ -1,278 +0,0 @@
-defmodule HashSet do
-  @moduledoc """
-  WARNING: this module is deprecated.
-
-  Use the `MapSet` module instead.
-  """
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-
-  @node_bitmap 0b111
-  @node_shift 3
-  @node_size 8
-  @node_template :erlang.make_tuple(@node_size, [])
-
-  @opaque t :: %__MODULE__{size: non_neg_integer, root: term}
-  @doc false
-  defstruct size: 0, root: @node_template
-
-  # Inline common instructions
-  @compile :inline_list_funcs
-  @compile {:inline, key_hash: 1, key_mask: 1, key_shift: 1}
-
-  @spec new :: Set.t
-  def new do
-    %HashSet{}
-  end
-
-  def union(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) when size1 <= size2 do
-    set_fold set1, set2, fn v, acc -> put(acc, v) end
-  end
-
-  def union(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set2, set1, fn v, acc -> put(acc, v) end
-  end
-
-  def intersection(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set1, %HashSet{}, fn v, acc ->
-      if member?(set2, v), do: put(acc, v), else: acc
-    end
-  end
-
-  def difference(%HashSet{} = set1, %HashSet{} = set2) do
-    set_fold set2, set1, fn v, acc -> delete(acc, v) end
-  end
-
-  def to_list(set) do
-    set_fold(set, [], &[&1 | &2]) |> :lists.reverse
-  end
-
-  def equal?(%HashSet{size: size1} = set1, %HashSet{size: size2} = set2) do
-    case size1 do
-      ^size2 -> subset?(set1, set2)
-      _      -> false
-    end
-  end
-
-  def subset?(%HashSet{} = set1, %HashSet{} = set2) do
-    reduce(set1, {:cont, true}, fn member, acc ->
-      case member?(set2, member) do
-        true -> {:cont, acc}
-        _    -> {:halt, false}
-      end
-    end) |> elem(1)
-  end
-
-  def disjoint?(%HashSet{} = set1, %HashSet{} = set2) do
-    reduce(set2, {:cont, true}, fn member, acc ->
-      case member?(set1, member) do
-        false -> {:cont, acc}
-        _     -> {:halt, false}
-      end
-    end) |> elem(1)
-  end
-
-  def member?(%HashSet{root: root}, term) do
-    do_member?(root, term, key_hash(term))
-  end
-
-  def put(%HashSet{root: root, size: size}, term) do
-    {root, counter} = do_put(root, term, key_hash(term))
-    %HashSet{root: root, size: size + counter}
-  end
-
-  def delete(%HashSet{root: root, size: size} = set, term) do
-    case do_delete(root, term, key_hash(term)) do
-      {:ok, root} -> %HashSet{root: root, size: size - 1}
-      :error      -> set
-    end
-  end
-
-  @doc false
-  def reduce(%HashSet{root: root}, acc, fun) do
-    do_reduce(root, acc, fun, @node_size, fn
-      {:suspend, acc} -> {:suspended, acc, &{:done, elem(&1, 1)}}
-      {:halt, acc}    -> {:halted, acc}
-      {:cont, acc}    -> {:done, acc}
-    end)
-  end
-
-  def size(%HashSet{size: size}) do
-    size
-  end
-
-  ## Set helpers
-
-  defp set_fold(%HashSet{root: root}, acc, fun) do
-    do_fold(root, acc, fun, @node_size)
-  end
-
-  ## Set manipulation
-
-  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))
-    end
-  end
-
-  defp do_put(node, term, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [] ->
-        {put_elem(node, index, [term]), 1}
-      [^term | _] ->
-        {node, 0}
-      [t] ->
-        n = put_elem(@node_template, key_mask(key_shift(hash)), [term])
-        {put_elem(node, index, [t | n]), 1}
-      [t | n] ->
-        {n, counter} = do_put(n, term, key_shift(hash))
-        {put_elem(node, index, [t | n]), counter}
-    end
-  end
-
-  defp do_delete(node, term, hash) do
-    index = key_mask(hash)
-    case elem(node, index) do
-      [] ->
-        :error
-      [^term] ->
-        {:ok, put_elem(node, index, [])}
-      [_] ->
-        :error
-      [^term | n] ->
-        {:ok, put_elem(node, index, do_compact_node(n))}
-      [t | n] ->
-        case do_delete(n, term, key_shift(hash)) do
-          {:ok, @node_template} ->
-            {:ok, put_elem(node, index, [t])}
-          {:ok, n} ->
-            {:ok, put_elem(node, index, [t | n])}
-          :error ->
-            :error
-        end
-    end
-  end
-
-  Enum.each 0..(@node_size - 1), fn index ->
-    defp do_compact_node(node) when elem(node, unquote(index)) != [] do
-      case elem(node, unquote(index)) do
-        [t] ->
-          case put_elem(node, unquote(index), []) do
-            @node_template -> [t]
-            n -> [t | n]
-          end
-        [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(node, acc, fun, count) when count > 0 do
-    acc = do_fold_each(:erlang.element(count, node), acc, fun)
-    do_fold(node, acc, fun, count - 1)
-  end
-
-  defp do_fold(_node, acc, _fun, 0) do
-    acc
-  end
-
-  ## Set reduce
-
-  defp do_reduce_each(_node, {:halt, acc}, _fun, _next) do
-    {:halted, acc}
-  end
-
-  defp do_reduce_each(node, {:suspend, acc}, fun, next) do
-    {:suspended, acc, &do_reduce_each(node, &1, fun, next)}
-  end
-
-  defp do_reduce_each([], acc, _fun, next) do
-    next.(acc)
-  end
-
-  defp do_reduce_each([t], {:cont, acc}, fun, next) do
-    next.(fun.(t, acc))
-  end
-
-  defp do_reduce_each([t | n], {:cont, acc}, fun, next) do
-    do_reduce(n, fun.(t, acc), fun, @node_size, next)
-  end
-
-  defp do_reduce(node, acc, fun, count, next) when count > 0 do
-    do_reduce_each(:erlang.element(count, node), acc, fun, &do_reduce(node, &1, fun, count - 1, next))
-  end
-
-  defp do_reduce(_node, acc, _fun, 0, next) do
-    next.(acc)
-  end
-
-  ## Key operations
-
-  import Bitwise
-
-  defp key_hash(key) do
-    :erlang.phash2(key)
-  end
-
-  defp key_mask(hash) do
-    hash &&& @node_bitmap
-  end
-
-  defp key_shift(hash) do
-    hash >>> @node_shift
-  end
-end
-
-defimpl Enumerable, for: HashSet do
-  def reduce(set, acc, fun) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    module.reduce(set, acc, fun)
-  end
-
-  def member?(set, term) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.member?(set, term)}
-  end
-
-  def count(set) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {:ok, module.size(set)}
-  end
-end
-
-defimpl Collectable, for: HashSet do
-  def into(original) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    {original, fn
-      set, {:cont, term} -> module.put(set, term)
-      set, :done -> set
-      _, :halt -> :ok
-    end}
-  end
-end
-
-defimpl Inspect, for: HashSet do
-  import Inspect.Algebra
-
-  def inspect(set, opts) do
-    # Avoid warnings about HashSet being deprecated.
-    module = HashSet
-    concat ["#HashSet<", Inspect.List.inspect(module.to_list(set), opts), ">"]
-  end
-end

lib/elixir/lib/inspect.ex

@@ -1,575 +0,0 @@
-import Kernel, except: [inspect: 1]
-import Inspect.Algebra
-
-defprotocol Inspect do
-  @moduledoc """
-  The `Inspect` protocol is responsible for converting any Elixir
-  data structure into an algebra document. This document is then
-  formatted, either in pretty printing format or a regular one.
-
-  The `inspect/2` function receives the entity to be inspected
-  followed by the inspecting options, represented by the struct
-  `Inspect.Opts`.
-
-  Inspection is done using the functions available in `Inspect.Algebra`.
-
-  ## Examples
-
-  Many times, inspecting a structure can be implemented in function
-  of existing entities. For example, here is `MapSet`'s `inspect`
-  implementation:
-
-      defimpl Inspect, for: MapSet do
-        import Inspect.Algebra
-
-        def inspect(dict, opts) do
-          concat ["#MapSet<", to_doc(MapSet.to_list(dict), opts), ">"]
-        end
-      end
-
-  The `concat/1` function comes from `Inspect.Algebra` and it
-  concatenates algebra documents together. In the example above,
-  it is concatenating the string `"MapSet<"` (all strings are
-  valid algebra documents that keep their formatting when pretty
-  printed), the document returned by `Inspect.Algebra.to_doc/2` and the
-  other string `">"`.
-
-  Since regular strings are valid entities in an algebra document,
-  an implementation of inspect may simply return a string,
-  although that will devoid it of any pretty-printing.
-
-  ## Error handling
-
-  In case there is an error while your structure is being inspected,
-  Elixir will raise an `ArgumentError` error and will automatically fall back
-  to a raw representation for printing the structure.
-
-  You can however access the underlying error by invoking the Inspect
-  implementation directly. For example, to test Inspect.MapSet above,
-  you can invoke it as:
-
-      Inspect.MapSet.inspect(MapSet.new, %Inspect.Opts{})
-
-  """
-
-  # Handle structs in Any
-  @fallback_to_any true
-
-  def inspect(term, opts)
-end
-
-defimpl Inspect, for: Atom do
-  require Macro
-
-  def inspect(atom, opts) do
-    color(inspect(atom), color_key(atom), opts)
-  end
-
-  defp color_key(atom) when is_boolean(atom), do: :boolean
-  defp color_key(nil), do: :nil
-  defp color_key(_), do: :atom
-
-  def inspect(atom) when is_nil(atom) or is_boolean(atom) do
-    Atom.to_string(atom)
-  end
-
-  def inspect(atom) when is_atom(atom) do
-    binary = Atom.to_string(atom)
-
-    case Macro.classify_identifier(atom) do
-      :alias ->
-        case binary do
-          binary when binary in ["Elixir", "Elixir.Elixir"] ->
-            binary
-          "Elixir.Elixir." <> _rest ->
-            binary
-          "Elixir." <> rest ->
-            rest
-        end
-      type when type in [:callable, :not_callable] ->
-        ":" <> binary
-      :other ->
-        {escaped, _} = Inspect.BitString.escape(binary, ?")
-        IO.iodata_to_binary [?:, ?", escaped, ?"]
-    end
-  end
-end
-
-defimpl Inspect, for: BitString do
-  def inspect(term, opts) when is_binary(term) do
-    %Inspect.Opts{binaries: bins, base: base, printable_limit: printable_limit} = opts
-
-    if base == :decimal and
-       (bins == :as_strings or (bins == :infer and String.printable?(term, printable_limit))) do
-      inspected =
-        case escape(term, ?", printable_limit) do
-          {escaped, ""} -> [?", escaped, ?"]
-          {escaped, _} -> [?", escaped, ?", " <> ..."]
-        end
-      color(IO.iodata_to_binary(inspected), :string, opts)
-    else
-      inspect_bitstring(term, opts)
-    end
-  end
-
-  def inspect(term, opts) do
-    inspect_bitstring(term, opts)
-  end
-
-  ## Escaping
-
-  @doc false
-  def escape(other, char) do
-    escape(other, char, :infinity, [])
-  end
-
-  @doc false
-  def escape(other, char, count) do
-    escape(other, char, count, [])
-  end
-
-  defp escape(<<_, _::binary>> = binary, _char, 0, acc) do
-    {acc, binary}
-  end
-  defp escape(<<char, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | [?\\, char]])
-  end
-  defp escape(<<?#, ?{, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\\#{'])
-  end
-  defp escape(<<?\a, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\a'])
-  end
-  defp escape(<<?\b, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\b'])
-  end
-  defp escape(<<?\d, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\d'])
-  end
-  defp escape(<<?\e, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\e'])
-  end
-  defp escape(<<?\f, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\f'])
-  end
-  defp escape(<<?\n, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\n'])
-  end
-  defp escape(<<?\r, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\r'])
-  end
-  defp escape(<<?\\, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\\\'])
-  end
-  defp escape(<<?\t, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\t'])
-  end
-  defp escape(<<?\v, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | '\\v'])
-  end
-  defp escape(<<h::utf8, t::binary>>, char, count, acc)
-       when h in 0x20..0x7E
-       when h in 0xA0..0xD7FF
-       when h in 0xE000..0xFFFD
-       when h in 0x10000..0x10FFFF do
-    escape(t, char, decrement(count), [acc | <<h::utf8>>])
-  end
-  defp escape(<<h, t::binary>>, char, count, acc) do
-    escape(t, char, decrement(count), [acc | escape_char(h)])
-  end
-  defp escape(<<>>, _char, _count, acc) do
-    {acc, <<>>}
-  end
-
-  @doc false
-  # Also used by Regex
-  def escape_char(0) do
-    '\\0'
-  end
-
-  def escape_char(char) when char < 0x100 do
-    <<a::4, b::4>> = <<char::8>>
-    ['\\x', to_hex(a), to_hex(b)]
-  end
-
-  def escape_char(char) when char < 0x10000 do
-    <<a::4, b::4, c::4, d::4>> = <<char::16>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}]
-  end
-
-  def escape_char(char) when char < 0x1000000 do
-    <<a::4, b::4, c::4, d::4, e::4, f::4>> = <<char::24>>
-    ['\\x{', to_hex(a), to_hex(b), to_hex(c),
-             to_hex(d), to_hex(e), to_hex(f), ?}]
-  end
-
-  defp to_hex(c) when c in 0..9, do: ?0 + c
-  defp to_hex(c) when c in 10..15, do: ?A + c - 10
-
-  ## Bitstrings
-
-  defp inspect_bitstring("", opts) do
-    color("<<>>", :binary, opts)
-  end
-
-  defp inspect_bitstring(bitstring, opts) do
-    left = color("<<", :binary, opts)
-    right = color(">>", :binary, opts)
-    nest surround(left, each_bit(bitstring, opts.limit, opts), right), 1
-  end
-
-  defp each_bit(_, 0, _) do
-    "..."
-  end
-
-  defp each_bit(<<>>, _counter, _opts) do
-    :doc_nil
-  end
-
-  defp each_bit(<<h::8>>, _counter, opts) do
-    Inspect.Integer.inspect(h, opts)
-  end
-
-  defp each_bit(<<h, t::bitstring>>, counter, opts) do
-    glue(concat(Inspect.Integer.inspect(h, opts), ","),
-         each_bit(t, decrement(counter), opts))
-  end
-
-  defp each_bit(bitstring, _counter, opts) do
-    size = bit_size(bitstring)
-    <<h::size(size)>> = bitstring
-    Inspect.Integer.inspect(h, opts) <> "::size(" <> Integer.to_string(size) <> ")"
-  end
-
-  @compile {:inline, decrement: 1}
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
-end
-
-defimpl Inspect, for: List do
-  def inspect([], opts) do
-    color("[]", :list, opts)
-  end
-
-  # TODO: Remove :char_list and :as_char_lists handling in 2.0
-  def inspect(term, opts) do
-    %Inspect.Opts{charlists: lists, char_lists: lists_deprecated, printable_limit: printable_limit} = opts
-    lists =
-      if lists == :infer and lists_deprecated != :infer do
-        case lists_deprecated do
-          :as_char_lists ->
-            IO.warn "the :char_lists inspect option and its :as_char_lists " <>
-              "value are deprecated, use the :charlists option and its " <>
-              ":as_charlists value instead"
-            :as_charlists
-          _ ->
-            IO.warn "the :char_lists inspect option is deprecated, use :charlists instead"
-            lists_deprecated
-        end
-      else
-        lists
-      end
-
-    open = color("[", :list, opts)
-    sep = color(",", :list, opts)
-    close = color("]", :list, opts)
-
-    cond do
-      lists == :as_charlists or (lists == :infer and printable?(term, printable_limit)) ->
-        inspected =
-          case Inspect.BitString.escape(IO.chardata_to_string(term), ?', printable_limit) do
-            {escaped, ""} -> [?', escaped, ?']
-            {escaped, _} -> [?', escaped, ?', " ++ ..."]
-          end
-        IO.iodata_to_binary inspected
-      keyword?(term) ->
-        surround_many(open, term, close, opts, &keyword/2, sep)
-      true ->
-        surround_many(open, term, close, opts, &to_doc/2, sep)
-    end
-  end
-
-  @doc false
-  def keyword({key, value}, opts) do
-    key = color(key_to_binary(key) <> ": ", :atom, opts)
-    concat(key, to_doc(value, opts))
-  end
-
-  @doc false
-  def keyword?([{key, _value} | rest]) when is_atom(key) do
-    case Atom.to_charlist(key) do
-      'Elixir.' ++ _ -> false
-      _ -> keyword?(rest)
-    end
-  end
-
-  def keyword?([]),     do: true
-  def keyword?(_other), do: false
-
-  @doc false
-  def printable?(list), do: printable?(list, :infinity)
-
-  @doc false
-  def printable?(_, 0), do: true
-  def printable?([char | rest], counter) when char in 32..126, do: printable?(rest, decrement(counter))
-  def printable?([?\n | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\r | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\t | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\v | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\b | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\f | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\e | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([?\a | rest], counter), do: printable?(rest, decrement(counter))
-  def printable?([], _counter), do: true
-  def printable?(_, _counter), do: false
-
-  @compile {:inline, decrement: 1}
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
-
-  ## Private
-
-  defp key_to_binary(key) do
-    case Inspect.Atom.inspect(key) do
-      ":" <> right -> right
-      other -> other
-    end
-  end
-end
-
-defimpl Inspect, for: Tuple do
-  def inspect(tuple, opts) do
-    open = color("{", :tuple, opts)
-    sep = color(",", :tuple, opts)
-    close = color("}", :tuple, opts)
-    surround_many(open, Tuple.to_list(tuple), close, opts, &to_doc/2, sep)
-  end
-end
-
-defimpl Inspect, for: Map do
-  def inspect(map, opts) do
-    nest inspect(map, "", opts), 1
-  end
-
-  def inspect(map, name, opts) do
-    map = :maps.to_list(map)
-    open = color("%" <> name <> "{", :map, opts)
-    sep = color(",", :map, opts)
-    close = color("}", :map, opts)
-    surround_many(open, map, close, opts, traverse_fun(map, opts), sep)
-  end
-
-  defp traverse_fun(list, opts) do
-    if Inspect.List.keyword?(list) do
-      &Inspect.List.keyword/2
-    else
-      sep = color(" => ", :map, opts)
-      &to_map(&1, &2, sep)
-    end
-  end
-
-  defp to_map({key, value}, opts, sep) do
-    concat(
-      concat(to_doc(key, opts), sep),
-      to_doc(value, opts)
-    )
-  end
-end
-
-defimpl Inspect, for: Integer do
-  def inspect(term, %Inspect.Opts{base: base} = opts) do
-    inspected = Integer.to_string(term, base_to_value(base)) |> prepend_prefix(base)
-    color(inspected, :number, opts)
-  end
-
-  defp base_to_value(base) do
-    case base do
-      :binary  -> 2
-      :decimal -> 10
-      :octal   -> 8
-      :hex     -> 16
-    end
-  end
-
-  defp prepend_prefix(value, :decimal), do: value
-  defp prepend_prefix(value, base) do
-    prefix = case base do
-      :binary -> "0b"
-      :octal  -> "0o"
-      :hex    -> "0x"
-    end
-    prefix <> value
-  end
-end
-
-defimpl Inspect, for: Float do
-  def inspect(term, opts) do
-    inspected = IO.iodata_to_binary(:io_lib_format.fwrite_g(term))
-    color(inspected, :number, opts)
-  end
-end
-
-defimpl Inspect, for: Regex do
-  def inspect(regex, opts) do
-    source = IO.iodata_to_binary(['~r/', escape(regex.source, ?/), ?/, regex.opts])
-    color(source, :regex, opts)
-  end
-
-  defp escape(bin, term),
-    do: escape(bin, [], term)
-
-  defp escape(<<term, rest::binary>>, buf, term),
-    do: escape(rest, [buf | [?\\, term]], term)
-
-  # The list of characters is from 'String.printable?' implementation
-  # minus characters treated specially by regex: \s, \d, \b, \e
-
-  defp escape(<<?\n, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\n'], term)
-
-  defp escape(<<?\r, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\r'], term)
-
-  defp escape(<<?\t, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\t'], term)
-
-  defp escape(<<?\v, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\v'], term)
-
-  defp escape(<<?\f, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\f'], term)
-
-  defp escape(<<?\a, rest::binary>>, buf, term),
-    do: escape(rest, [buf | '\\a'], term)
-
-  defp escape(<<char::utf8, rest::binary>>, buf, term)
-       when char in 0x20..0x7E
-       when char in 0xA0..0xD7FF
-       when char in 0xE000..0xFFFD
-       when char in 0x10000..0x10FFFF,
-    do: escape(rest, [buf | <<char::utf8>>], term)
-
-  defp escape(<<char, rest::binary>>, buf, term),
-    do: escape(rest, [buf | Inspect.BitString.escape_char(char)], term)
-
-  defp escape(<<>>, buf, _), do: buf
-end
-
-defimpl Inspect, for: Function do
-  def inspect(function, _opts) do
-    fun_info = :erlang.fun_info(function)
-    mod = fun_info[:module]
-    name = fun_info[:name]
-
-    if fun_info[:type] == :external and fun_info[:env] == [] do
-      "&#{Inspect.Atom.inspect(mod)}.#{escape_name(name)}/#{fun_info[:arity]}"
-    else
-      case Atom.to_charlist(mod) do
-        'elixir_compiler_' ++ _ ->
-          if function_exported?(mod, :__RELATIVE__, 0) do
-            "#Function<#{uniq(fun_info)} in file:#{mod.__RELATIVE__}>"
-          else
-            default_inspect(mod, fun_info)
-          end
-        _ ->
-          default_inspect(mod, fun_info)
-      end
-    end
-  end
-
-  def escape_name(atom) when is_atom(atom) do
-    string = Atom.to_string(atom)
-
-    case Macro.classify_identifier(atom) do
-      :callable ->
-        string
-      type when type in [:not_callable, :alias] ->
-        "\"" <> string <> "\""
-      :other ->
-        {escaped, _} = Inspect.BitString.escape(string, ?")
-        IO.iodata_to_binary [?", escaped, ?"]
-    end
-  end
-
-  # Example of this format: -NAME/ARITY-fun-COUNT-
-  def extract_anonymous_fun_parent(atom) when is_atom(atom) do
-    extract_anonymous_fun_parent(Atom.to_string(atom))
-  end
-
-  def extract_anonymous_fun_parent("-" <> rest) do
-    [trailing | reversed] =
-      rest
-      |> String.split("/")
-      |> Enum.reverse()
-
-    case String.split(trailing, "-") do
-      [arity, _inner, _count, ""] ->
-        {reversed |> Enum.reverse |> Enum.join("/") |> String.to_atom(), arity}
-      _other ->
-        :error
-    end
-  end
-
-  def extract_anonymous_fun_parent(other) when is_binary(other), do: :error
-
-  defp default_inspect(mod, fun_info) do
-    "#Function<#{uniq(fun_info)}/#{fun_info[:arity]} in " <>
-      "#{Inspect.Atom.inspect(mod)}#{extract_name(fun_info[:name])}>"
-  end
-
-  defp extract_name([]) do
-    ""
-  end
-
-  defp extract_name(name) do
-    case extract_anonymous_fun_parent(name) do
-      {name, arity} ->
-        "." <> escape_name(name) <> "/" <> arity
-      :error ->
-        "." <> escape_name(name)
-    end
-  end
-
-  defp uniq(fun_info) do
-    Integer.to_string(fun_info[:new_index]) <> "." <>
-      Integer.to_string(fun_info[:uniq])
-  end
-end
-
-defimpl Inspect, for: PID do
-  def inspect(pid, _opts) do
-    "#PID" <> IO.iodata_to_binary(:erlang.pid_to_list(pid))
-  end
-end
-
-defimpl Inspect, for: Port do
-  def inspect(port, _opts) do
-    IO.iodata_to_binary(:erlang.port_to_list(port))
-  end
-end
-
-defimpl Inspect, for: Reference do
-  def inspect(ref, _opts) do
-    '#Ref' ++ rest = :erlang.ref_to_list(ref)
-    "#Reference" <> IO.iodata_to_binary(rest)
-  end
-end
-
-defimpl Inspect, for: Any do
-  def inspect(%{__struct__: struct} = map, opts) do
-    try do
-      struct.__struct__
-    rescue
-      _ -> Inspect.Map.inspect(map, opts)
-    else
-      dunder ->
-        if :maps.keys(dunder) == :maps.keys(map) do
-          pruned = :maps.remove(:__exception__, :maps.remove(:__struct__, map))
-          colorless_opts = %{opts | syntax_colors: []}
-          Inspect.Map.inspect(pruned, Inspect.Atom.inspect(struct, colorless_opts), opts)
-        else
-          Inspect.Map.inspect(map, opts)
-        end
-    end
-  end
-end

lib/elixir/lib/inspect/algebra.ex

@@ -1,670 +0,0 @@
-defmodule Inspect.Opts do
-  @moduledoc """
-  Defines the Inspect.Opts used by the Inspect protocol.
-
-  The following fields are available:
-
-    * `:structs` - when `false`, structs are not formatted by the inspect
-      protocol, they are instead printed as maps, defaults to `true`.
-
-    * `:binaries` - when `:as_strings` all binaries will be printed as strings,
-      non-printable bytes will be escaped.
-
-      When `:as_binaries` all binaries will be printed in bit syntax.
-
-      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
-      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
-      is printable, otherwise as list.
-
-    * `:limit` - limits the number of items that are printed for tuples,
-      bitstrings, maps, lists and any other collection of items. It does not
-      apply to strings nor charlists and defaults to 50.
-
-    * `:printable_limit` - limits the number of bytes that are printed for strings
-      and char lists. Defaults to 4096.
-
-    * `: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.
-
-    * `:base` - prints integers as `:binary`, `:octal`, `:decimal`, or `:hex`,
-      defaults to `:decimal`. When inspecting binaries any `:base` other than
-      `:decimal` implies `binaries: :as_binaries`.
-
-    * `:safe` - when `false`, failures while inspecting structs will be raised
-      as errors instead of being wrapped in the `Inspect.Error` exception. This
-      is useful when debugging failures and crashes for custom inspect
-      implementations
-
-    * `:syntax_colors` - when set to a keyword list of colors the output will
-      be colorized. The keys are types and the values are the colors to use for
-      each type. e.g. `[number: :red, atom: :blue]`. Types can include
-      `:number`, `:atom`, `regex`, `:tuple`, `:map`, `:list`, and `:reset`.
-      Colors can be any `t:IO.ANSI.ansidata/0` as accepted by `IO.ANSI.format/1`.
-  """
-
-  # TODO: Remove :char_lists key by 2.0
-  defstruct structs: true,
-            binaries: :infer,
-            charlists: :infer,
-            char_lists: :infer,
-            limit: 50,
-            printable_limit: 4096,
-            width: 80,
-            base: :decimal,
-            pretty: false,
-            safe: true,
-            syntax_colors: []
-
-  @type color_key :: atom
-
-  # TODO: Remove :char_lists key and :as_char_lists value by 2.0
-  @type t :: %__MODULE__{
-               structs: boolean,
-               binaries: :infer | :as_binaries | :as_strings,
-               charlists: :infer | :as_lists | :as_charlists,
-               char_lists: :infer | :as_lists | :as_char_lists,
-               limit: pos_integer | :infinity,
-               printable_limit: pos_integer | :infinity,
-               width: pos_integer | :infinity,
-               base: :decimal | :binary | :hex | :octal,
-               pretty: boolean,
-               safe: boolean,
-               syntax_colors: [{color_key, IO.ANSI.ansidata}]
-             }
-end
-
-defmodule Inspect.Error do
-  @moduledoc """
-  Raised when a struct cannot be inspected.
-  """
-  defexception [:message]
-end
-
-defmodule Inspect.Algebra do
-  @moduledoc ~S"""
-  A set of functions for creating and manipulating algebra
-  documents.
-
-  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.
-
-      iex> Inspect.Algebra.empty
-      :doc_nil
-
-      iex> "foo"
-      "foo"
-
-  With the functions in this module, we can concatenate different
-  elements together and render them:
-
-      iex> doc = Inspect.Algebra.concat(Inspect.Algebra.empty, "foo")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["foo"]
-
-  The functions `nest/2`, `space/2` and `line/2` help you put the
-  document together into a rigid structure. However, the document
-  algebra gets interesting when using functions like `break/1`, which
-  converts the given string into a line break depending on how much space
-  there is to print. Let's glue two docs together with a break and then
-  render it:
-
-      iex> doc = Inspect.Algebra.glue("a", " ", "b")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["a", " ", "b"]
-
-  Notice the break was represented as is, because we haven't reached
-  a line limit. Once we do, it is replaced by a newline:
-
-      iex> doc = Inspect.Algebra.glue(String.duplicate("a", 20), " ", "b")
-      iex> Inspect.Algebra.format(doc, 10)
-      ["aaaaaaaaaaaaaaaaaaaa", "\n", "b"]
-
-  Finally, this module also contains Elixir related functions, a bit
-  tied to Elixir formatting, namely `surround/3` and `surround_many/5`.
-
-  ## Implementation details
-
-  The original Haskell implementation of the algorithm by [Wadler][1]
-  relies on lazy evaluation to unfold document groups on two alternatives:
-  `: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
-  to a simple document, where the layout is already decided, per [Lindig][0].
-
-  This implementation slightly changes the semantic of Lindig's algorithm
-  to allow elements that belong to the same group to be printed together
-  in the same line, even if they do not fit the line fully. This was achieved
-  by changing `:break` to mean a possible break and `:flat` to force a flat
-  structure. Then deciding if a break works as a newline is just a matter
-  of checking if we have enough space until the next break that is not
-  inside a group (which is still flat).
-
-  Custom pretty printers can be implemented using the documents returned
-  by this module and by providing their own rendering functions.
-
-    [0]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.34.2200
-    [1]: http://homepages.inf.ed.ac.uk/wadler/papers/prettier/prettier.pdf
-
-  """
-
-  @surround_separator ","
-  @tail_separator " |"
-  @newline "\n"
-  @nesting 1
-  @space " "
-
-  # Functional interface to "doc" records
-
-  @type t :: :doc_nil | :doc_line | doc_cons | doc_nest | doc_break | doc_group | doc_color | binary
-
-  @typep doc_cons :: {:doc_cons, t, t}
-  defmacrop doc_cons(left, right) do
-    quote do: {:doc_cons, unquote(left), unquote(right)}
-  end
-
-  @typep doc_nest :: {:doc_nest, t, non_neg_integer}
-  defmacrop doc_nest(doc, indent) do
-    quote do: {:doc_nest, unquote(doc), unquote(indent)}
-  end
-
-  @typep doc_break :: {:doc_break, binary}
-  defmacrop doc_break(break) do
-    quote do: {:doc_break, unquote(break)}
-  end
-
-  @typep doc_group :: {:doc_group, t}
-  defmacrop doc_group(group) do
-    quote do: {:doc_group, unquote(group)}
-  end
-
-  @typep doc_color :: {:doc_color, t, IO.ANSI.ansidata}
-  defmacrop doc_color(doc, color) do
-    quote do: {:doc_color, unquote(doc), unquote(color)}
-  end
-
-  defmacrop is_doc(doc) do
-    if Macro.Env.in_guard?(__CALLER__) do
-      do_is_doc(doc)
-    else
-      var = quote do: doc
-      quote do
-        unquote(var) = unquote(doc)
-        unquote(do_is_doc(var))
-      end
-    end
-  end
-
-  defp do_is_doc(doc) do
-    quote do
-      is_binary(unquote(doc)) or
-      unquote(doc) in [:doc_nil, :doc_line] or
-      (is_tuple(unquote(doc)) and
-       elem(unquote(doc), 0) in [:doc_cons, :doc_nest, :doc_break, :doc_group, :doc_color])
-    end
-  end
-
-  @doc """
-  Converts an Elixir term to an algebra document
-  according to the `Inspect` protocol.
-  """
-  @spec to_doc(any, Inspect.Opts.t) :: t
-  def to_doc(term, opts)
-
-  def to_doc(%{__struct__: struct} = map, %Inspect.Opts{} = opts) when is_atom(struct) do
-    if opts.structs do
-      try do
-        Inspect.inspect(map, opts)
-      rescue
-        e ->
-          stacktrace = System.stacktrace
-
-          # Because we try to raise a nice error message in case
-          # we can't inspect a struct, there is a chance the error
-          # message itself relies on the struct being printed, so
-          # we need to trap the inspected messages to guarantee
-          # we won't try to render any failed instruct when building
-          # the error message.
-          if Process.get(:inspect_trap) do
-            Inspect.Map.inspect(map, opts)
-          else
-            try do
-              Process.put(:inspect_trap, true)
-
-              res = Inspect.Map.inspect(map, %{opts | syntax_colors: []})
-              res = IO.iodata_to_binary(format(res, :infinity))
-
-              exception = Inspect.Error.exception(
-                message: "got #{inspect e.__struct__} with message " <>
-                         "#{inspect Exception.message(e)} while inspecting #{res}"
-              )
-
-              if opts.safe do
-                Inspect.inspect(exception, opts)
-              else
-                reraise(exception, stacktrace)
-              end
-            after
-              Process.delete(:inspect_trap)
-            end
-          end
-      end
-    else
-      Inspect.Map.inspect(map, opts)
-    end
-  end
-
-  def to_doc(arg, %Inspect.Opts{} = opts) do
-    Inspect.inspect(arg, opts)
-  end
-
-  @doc """
-  Returns a document entity used to represent nothingness.
-
-  ## Examples
-
-      iex> Inspect.Algebra.empty
-      :doc_nil
-
-  """
-  @spec empty() :: :doc_nil
-  def empty, do: :doc_nil
-
-  @doc ~S"""
-  Concatenates two document entities returning a new document.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.concat("hello", "world")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["hello", "world"]
-
-  """
-  @spec concat(t, t) :: t
-  def concat(doc1, doc2) when is_doc(doc1) and is_doc(doc2) do
-    doc_cons(doc1, doc2)
-  end
-
-  @doc ~S"""
-  Concatenates a list of documents returning a new document.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.concat(["a", "b", "c"])
-      iex> Inspect.Algebra.format(doc, 80)
-      ["a", "b", "c"]
-
-  """
-  @spec concat([t]) :: t
-  def concat(docs) when is_list(docs) do
-    fold_doc(docs, &concat(&1, &2))
-  end
-
-  @doc ~S"""
-  Colors a document if the `color_key` has a color in the options.
-  """
-  @spec color(t, Inspect.Opts.color_key, Inspect.Opts.t) :: doc_color
-  def color(doc, color_key, %Inspect.Opts{syntax_colors: syntax_colors}) when is_doc(doc) do
-    if precolor = Keyword.get(syntax_colors, color_key) do
-      postcolor = Keyword.get(syntax_colors, :reset, :reset)
-      concat(doc_color(doc, precolor), doc_color(empty(), postcolor))
-    else
-      doc
-    end
-  end
-
-  @doc ~S"""
-  Nests the given document at the given `level`.
-
-  Nesting will be appended to the line breaks.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.nest(Inspect.Algebra.glue("hello", "world"), 5)
-      iex> Inspect.Algebra.format(doc, 5)
-      ["hello", "\n     ", "world"]
-
-  """
-  @spec nest(t, non_neg_integer) :: doc_nest
-  def nest(doc, level)
-
-  def nest(doc, 0) when is_doc(doc) do
-    doc
-  end
-
-  def nest(doc, level) when is_doc(doc) and is_integer(level) and level > 0 do
-    doc_nest(doc, level)
-  end
-
-  @doc ~S"""
-  Returns a document entity representing a break based on the given
-  `string`.
-
-  This break can be rendered as a linebreak or as the given `string`,
-  depending on the `mode` of the chosen layout or the provided
-  separator.
-
-  ## Examples
-
-  Let's create a document by concatenating two strings with a break between
-  them:
-
-      iex> doc = Inspect.Algebra.concat(["a", Inspect.Algebra.break("\t"), "b"])
-      iex> Inspect.Algebra.format(doc, 80)
-      ["a", "\t", "b"]
-
-  Notice the break was represented with the given string, because we didn't
-  reach a line limit. Once we do, it is replaced by a newline:
-
-      iex> break = Inspect.Algebra.break("\t")
-      iex> doc = Inspect.Algebra.concat([String.duplicate("a", 20), break, "b"])
-      iex> Inspect.Algebra.format(doc, 10)
-      ["aaaaaaaaaaaaaaaaaaaa", "\n", "b"]
-
-  """
-  @spec break(binary) :: doc_break
-  def break(string) when is_binary(string), do: doc_break(string)
-
-  @doc ~S"""
-  Returns a document entity with the `" "` string as break.
-
-  See `break/1` for more information.
-  """
-  @spec break() :: doc_break
-  def break(), do: doc_break(@space)
-
-  @doc ~S"""
-  Glues two documents together inserting `" "` as a break between them.
-
-  This means the two documents will be separated by `" "` in case they
-  fit in the same line. Otherwise a line break is used.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", "world")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["hello", " ", "world"]
-
-  """
-  @spec glue(t, t) :: t
-  def glue(doc1, doc2), do: concat(doc1, concat(break(), doc2))
-
-  @doc ~S"""
-  Glues two documents (`doc1` and `doc2`) together inserting the given
-  break `break_string` between them.
-
-  For more information on how the break is inserted, see `break/1`.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", "\t", "world")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["hello", "\t", "world"]
-
-  """
-  @spec glue(t, binary, t) :: t
-  def glue(doc1, break_string, doc2) when is_binary(break_string),
-    do: concat(doc1, concat(break(break_string), doc2))
-
-  @doc ~S"""
-  Returns a group containing the specified document `doc`.
-
-  Documents in a group are attempted to be rendered together
-  to the best of the renderer ability.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.group(
-      ...>   Inspect.Algebra.concat(
-      ...>     Inspect.Algebra.group(
-      ...>       Inspect.Algebra.concat(
-      ...>         "Hello,",
-      ...>         Inspect.Algebra.concat(
-      ...>           Inspect.Algebra.break,
-      ...>           "A"
-      ...>         )
-      ...>       )
-      ...>     ),
-      ...>     Inspect.Algebra.concat(
-      ...>       Inspect.Algebra.break,
-      ...>       "B"
-      ...>     )
-      ...> ))
-      iex> Inspect.Algebra.format(doc, 80)
-      ["Hello,", " ", "A", " ", "B"]
-      iex> Inspect.Algebra.format(doc, 6)
-      ["Hello,", "\n", "A", " ", "B"]
-
-  """
-  @spec group(t) :: doc_group
-  def group(doc) when is_doc(doc) do
-    doc_group(doc)
-  end
-
-  @doc ~S"""
-  Inserts a mandatory single space between two documents.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.space("Hughes", "Wadler")
-      iex> Inspect.Algebra.format(doc, 5)
-      ["Hughes", " ", "Wadler"]
-
-  """
-  @spec space(t, t) :: t
-  def space(doc1, doc2), do: concat(doc1, concat(" ", doc2))
-
-  @doc ~S"""
-  Inserts a mandatory linebreak between two documents.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.line("Hughes", "Wadler")
-      iex> Inspect.Algebra.format(doc, 80)
-      ["Hughes", "\n", "Wadler"]
-
-  """
-  @spec line(t, t) :: t
-  def line(doc1, doc2), do: concat(doc1, concat(:doc_line, doc2))
-
-  @doc ~S"""
-  Folds a list of documents into a document using the given folder function.
-
-  The list of documents is folded "from the right"; in that, this function is
-  similar to `List.foldr/3`, except that it doesn't expect an initial
-  accumulator and uses the last element of `docs` as the initial accumulator.
-
-  ## Examples
-
-      iex> docs = ["A", "B", "C"]
-      iex> docs = Inspect.Algebra.fold_doc(docs, fn(doc, acc) ->
-      ...>   Inspect.Algebra.concat([doc, "!", acc])
-      ...> end)
-      iex> Inspect.Algebra.format(docs, 80)
-      ["A", "!", "B", "!", "C"]
-
-  """
-  @spec fold_doc([t], ((t, t) -> t)) :: t
-  def fold_doc(docs, folder_fun)
-
-  def fold_doc([], _folder_fun),
-    do: empty()
-  def fold_doc([doc], _folder_fun),
-    do: doc
-  def fold_doc([doc | docs], folder_fun) when is_function(folder_fun, 2),
-    do: folder_fun.(doc, fold_doc(docs, folder_fun))
-
-  # Elixir conveniences
-
-  @doc ~S"""
-  Surrounds a document with characters.
-
-  Puts the given document `doc` between the `left` and `right` documents enclosing
-  and nesting it. The document is marked as a group, to show the maximum as
-  possible concisely together.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.surround("[", Inspect.Algebra.glue("a", "b"), "]")
-      iex> Inspect.Algebra.format(doc, 3)
-      ["[", "a", "\n ", "b", "]"]
-
-  """
-  @spec surround(t, t, t) :: t
-  def surround(left, doc, right) when is_doc(left) and is_doc(doc) and is_doc(right) do
-    group(concat(left, concat(nest(doc, @nesting), right)))
-  end
-
-  @doc ~S"""
-  Maps and glues a collection of items.
-
-  It uses the given `left` and `right` documents as surrounding and the
-  separator document `separator` to separate items in `docs`. A limit can be
-  passed: when this limit is reached, this function stops gluing and outputs
-  `"..."` instead.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
-      ...>         %Inspect.Opts{limit: :infinity}, fn i, _opts -> to_string(i) end)
-      iex> Inspect.Algebra.format(doc, 5) |> IO.iodata_to_binary
-      "[1,\n 2,\n 3,\n 4,\n 5]"
-
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
-      ...>         %Inspect.Opts{limit: 3}, fn i, _opts -> to_string(i) end)
-      iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary
-      "[1, 2, 3, ...]"
-
-      iex> doc = Inspect.Algebra.surround_many("[", Enum.to_list(1..5), "]",
-      ...>         %Inspect.Opts{limit: 3}, fn i, _opts -> to_string(i) end, "!")
-      iex> Inspect.Algebra.format(doc, 20) |> IO.iodata_to_binary
-      "[1! 2! 3! ...]"
-
-  """
-  @spec surround_many(t, [any], t, Inspect.Opts.t, (term, Inspect.Opts.t -> t), t) :: t
-  def surround_many(left, docs, right, %Inspect.Opts{} = opts, fun, separator \\ @surround_separator)
-      when is_doc(left) and is_list(docs) and is_doc(right) and is_function(fun, 2) and is_doc(separator) do
-    do_surround_many(left, docs, right, opts.limit, opts, fun, separator)
-  end
-
-  defp do_surround_many(left, [], right, _, _opts, _fun, _) do
-    concat(left, right)
-  end
-
-  defp do_surround_many(left, docs, right, limit, opts, fun, sep) do
-    surround(left, do_surround_many(docs, limit, opts, fun, sep), right)
-  end
-
-  defp do_surround_many(_, 0, _opts, _fun, _sep) do
-    "..."
-  end
-
-  defp do_surround_many([], _limit, _opts, _fun, _sep) do
-    :doc_nil
-  end
-
-  defp do_surround_many([h], limit, opts, fun, _sep) do
-    fun.(h, %{opts | limit: limit})
-  end
-
-  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
-    limit = decrement(limit)
-    h = fun.(h, %{opts | limit: limit})
-    t = fun.(t, %{opts | limit: limit})
-    do_join(h, t, @tail_separator)
-  end
-
-  defp do_join(:doc_nil, :doc_nil, _), do: :doc_nil
-  defp do_join(h, :doc_nil, _),        do: h
-  defp do_join(:doc_nil, t, _),        do: t
-  defp do_join(h, t, sep),             do: glue(concat(h, sep), t)
-
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
-
-  @doc ~S"""
-  Formats a given document for a given width.
-
-  Takes the maximum width and a document to print as its arguments
-  and returns an IO data representation of the best layout for the
-  document to fit in the given width.
-
-  ## Examples
-
-      iex> doc = Inspect.Algebra.glue("hello", " ", "world")
-      iex> Inspect.Algebra.format(doc, 30) |> IO.iodata_to_binary()
-      "hello world"
-      iex> Inspect.Algebra.format(doc, 10) |> IO.iodata_to_binary()
-      "hello\nworld"
-
-  """
-  @spec format(t, non_neg_integer | :infinity) :: iodata
-  def format(doc, width) when is_doc(doc) and (width == :infinity or width >= 0) do
-    format(width, 0, [{0, default_mode(width), doc_group(doc)}])
-  end
-
-  defp default_mode(:infinity), do: :flat
-  defp default_mode(_),         do: :break
-
-  # Record representing the document mode to be rendered: flat or broken
-  @typep mode :: :flat | :break
-
-  @spec fits?(integer, [{integer, mode, t}]) :: boolean
-  defp fits?(w, _) when w < 0,                      do: false
-  defp fits?(_, []),                                do: true
-  defp fits?(_, [{_, _, :doc_line} | _]),           do: true
-  defp fits?(w, [{_, _, :doc_nil} | t]),            do: fits?(w, t)
-  defp fits?(w, [{i, m, doc_cons(x, y)} | t]),      do: fits?(w, [{i, m, x} | [{i, m, y} | t]])
-  defp fits?(w, [{i, m, doc_color(x, _)} | t]),    do: fits?(w, [{i, m, x} | t])
-  defp fits?(w, [{i, m, doc_nest(x, j)} | t]),      do: fits?(w, [{i + j, m, x} | t])
-  defp fits?(w, [{i, _, doc_group(x)} | t]),        do: fits?(w, [{i, :flat, x} | t])
-  defp fits?(w, [{_, _, s} | t]) when is_binary(s), do: fits?((w - byte_size(s)), t)
-  defp fits?(w, [{_, :flat, doc_break(s)} | t]),    do: fits?((w - byte_size(s)), t)
-  defp fits?(_, [{_, :break, doc_break(_)} | _]),   do: true
-
-  @spec format(integer | :infinity, integer, [{integer, mode, t}]) :: [binary]
-  defp format(_, _, []),                                do: []
-  defp format(w, _, [{i, _, :doc_line} | t]),           do: [indent(i) | format(w, i, t)]
-  defp format(w, k, [{_, _, :doc_nil} | t]),            do: format(w, k, t)
-  defp format(w, k, [{i, m, doc_cons(x, y)} | t]),      do: format(w, k, [{i, m, x} | [{i, m, y} | t]])
-  defp format(w, k, [{i, m, doc_nest(x, j)} | t]),      do: format(w, k, [{i + j, m, x} | t])
-  defp format(w, k, [{i, m, doc_group(x)} | t]),        do: format(w, k, [{i, m, x} | t])
-  defp format(w, k, [{i, m, doc_color(x, c)} | t]),     do: [ansi(c) | format(w, k, [{i, m, x} | t])]
-  defp format(w, k, [{_, _, s} | t]) when is_binary(s), do: [s | format(w, (k + byte_size(s)), t)]
-  defp format(w, k, [{_, :flat, doc_break(s)} | t]),    do: [s | format(w, (k + byte_size(s)), t)]
-  defp format(w, k, [{i, :break, doc_break(s)} | t]) do
-    k = k + byte_size(s)
-
-    if w == :infinity or fits?(w - k, t) do
-      [s | format(w, k, t)]
-    else
-      [indent(i) | format(w, i, t)]
-    end
-  end
-
-  defp ansi(color) do
-    IO.ANSI.format_fragment(color, true)
-  end
-
-  defp indent(0), do: @newline
-  defp indent(i), do: @newline <> :binary.copy(" ", i)
-end

lib/elixir/lib/integer.ex

@@ -1,426 +0,0 @@
-defmodule Integer do
-  @moduledoc """
-  Functions for working with integers.
-  """
-
-  import Bitwise
-
-  @doc """
-  Determines if `integer` is odd.
-
-  Returns `true` if the given `integer` is an odd number,
-  otherwise it returns `false`.
-
-  Allowed in guard clauses.
-
-  ## Examples
-
-      iex> Integer.is_odd(5)
-      true
-
-      iex> Integer.is_odd(6)
-      false
-
-      iex> Integer.is_odd(-5)
-      true
-
-      iex> Integer.is_odd(0)
-      false
-
-  """
-  defmacro is_odd(integer) do
-    quote do: (unquote(integer) &&& 1) == 1
-  end
-
-  @doc """
-  Determines if an `integer` is even.
-
-  Returns `true` if the given `integer` is an even number,
-  otherwise it returns `false`.
-
-  Allowed in guard clauses.
-
-  ## Examples
-
-      iex> Integer.is_even(10)
-      true
-
-      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
-  end
-
-  @doc """
-  Computes the modulo remainder of an integer division.
-
-  `Integer.mod/2` uses floored division, which means that
-  the result will always have the sign of the `divisor`.
-
-  Raises an `ArithmeticError` exception if one of the arguments is not an
-  integer, or when the `divisor` is `0`.
-
-  ## Examples
-
-      iex> Integer.mod(5, 2)
-      1
-      iex> Integer.mod(6, -4)
-      -2
-
-  """
-  @spec mod(integer, neg_integer | pos_integer) :: integer
-  def mod(dividend, divisor) do
-    remainder = rem(dividend, divisor)
-    if remainder * divisor < 0 do
-      remainder + divisor
-    else
-      remainder
-    end
-  end
-
-  @doc """
-  Performs a floored integer division.
-
-  Raises an `ArithmeticError` exception if one of the arguments is not an
-  integer, or when the `divisor` is `0`.
-
-  `Integer.floor_div/2` performs *floored* integer division. This means that
-  the result is always rounded towards negative infinity.
-
-  If you want to perform truncated integer division (rounding towards zero),
-  use `Kernel.div/2` instead.
-
-  ## Examples
-
-      iex> Integer.floor_div(5, 2)
-      2
-      iex> Integer.floor_div(6, -4)
-      -2
-      iex> Integer.floor_div(-99, 2)
-      -50
-
-  """
-  @spec floor_div(integer, neg_integer | pos_integer) :: integer
-  def floor_div(dividend, divisor) do
-    if (dividend * divisor < 0) and rem(dividend, divisor) != 0 do
-      div(dividend, divisor) - 1
-    else
-      div(dividend, divisor)
-    end
-  end
-
-  @doc """
-  Returns the ordered digits for the given `integer`.
-
-  An optional `base` value may be provided representing the radix for the returned
-  digits. This one must be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.digits(123)
-      [1, 2, 3]
-
-      iex> Integer.digits(170, 2)
-      [1, 0, 1, 0, 1, 0, 1, 0]
-
-      iex> Integer.digits(-170, 2)
-      [-1, 0, -1, 0, -1, 0, -1, 0]
-
-  """
-  @spec digits(integer, pos_integer) :: [integer, ...]
-  def digits(integer, base \\ 10)
-      when is_integer(integer) and is_integer(base) and base >= 2 do
-    do_digits(integer, base, [])
-  end
-
-  defp do_digits(digit, base, []) when abs(digit) < base,
-    do: [digit]
-  defp do_digits(digit, base, []) when digit == -base,
-    do: [-1, 0]
-  defp do_digits(base, base, []),
-    do: [1, 0]
-  defp do_digits(0, _base, acc),
-    do: acc
-  defp do_digits(integer, base, acc),
-    do: do_digits(div(integer, base), base, [rem(integer, base) | acc])
-
-  @doc """
-  Returns the integer represented by the ordered `digits`.
-
-  An optional `base` value may be provided representing the radix for the `digits`.
-  This one can be an integer >= 2.
-
-  ## Examples
-
-      iex> Integer.undigits([1, 2, 3])
-      123
-
-      iex> Integer.undigits([1, 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
-    do_undigits(digits, base, 0)
-  end
-
-  defp do_undigits([], _base, 0),
-    do: 0
-  defp do_undigits([digit], base, 0) when is_integer(digit) and digit < base,
-    do: digit
-  defp do_undigits([1, 0], base, 0),
-    do: base
-  defp do_undigits([0 | tail], base, 0),
-    do: do_undigits(tail, base, 0)
-
-  defp do_undigits([], _base, acc),
-    do: acc
-  defp do_undigits([digit | _], base, _) when is_integer(digit) and digit >= base,
-    do: raise ArgumentError, "invalid digit #{digit} in base #{base}"
-  defp do_undigits([digit | tail], base, acc) when is_integer(digit),
-    do: do_undigits(tail, base, acc * base + digit)
-
-  @doc """
-  Parses a text representation of an integer.
-
-  An optional `base` to the corresponding integer can be provided.
-  If `base` is not given, 10 will be used.
-
-  If successful, returns a tuple in the form of `{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")
-      {34, ""}
-
-      iex> Integer.parse("34.5")
-      {34, ".5"}
-
-      iex> Integer.parse("three")
-      :error
-
-      iex> Integer.parse("34", 10)
-      {34, ""}
-
-      iex> Integer.parse("f4", 16)
-      {244, ""}
-
-      iex> Integer.parse("Awww++", 36)
-      {509216, "++"}
-
-      iex> Integer.parse("fab", 10)
-      :error
-
-      iex> Integer.parse("a2", 38)
-      ** (ArgumentError) invalid base 38
-
-  """
-  @spec parse(binary, 2..36) :: {integer, binary} | :error
-  def parse(binary, base \\ 10)
-
-  def parse(_binary, base) when not base in 2..36 do
-    raise ArgumentError, "invalid base #{inspect base}"
-  end
-
-  def parse(binary, base) do
-    case count_digits(binary, base) do
-      0 ->
-        :error
-      count ->
-        {digits, rem} = :erlang.split_binary(binary, count)
-        {:erlang.binary_to_integer(digits, base), rem}
-    end
-  end
-
-  defp count_digits(<<sign, rest::binary>>, base) when sign in '+-' do
-    case count_digits_nosign(rest, base, 1) do
-      1 -> 0
-      count -> count
-    end
-  end
-
-  defp count_digits(<<rest::binary>>, base) do
-    count_digits_nosign(rest, base, 0)
-  end
-
-  digits = [{?0..?9, -?0}, {?A..?Z, 10 - ?A}, {?a..?z, 10 - ?a}]
-
-  for {chars, diff} <- digits, char <- chars do
-    digit = char + diff
-
-    defp count_digits_nosign(<<unquote(char), rest::binary>>, base, count)
-        when base > unquote(digit) do
-      count_digits_nosign(rest, base, count + 1)
-    end
-  end
-
-  defp count_digits_nosign(<<_::binary>>, _, count), do: count
-
-  @doc """
-  Returns a binary which corresponds to the text representation
-  of `integer`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      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)
-  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.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      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)
-  end
-
-  @doc """
-  Returns a charlist 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'
-
-  """
-  @spec to_charlist(integer) :: charlist
-  def to_charlist(integer) do
-    :erlang.integer_to_list(integer)
-  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.
-
-  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'
-
-  """
-  @spec to_charlist(integer, 2..36) :: charlist
-  def to_charlist(integer, base) do
-    :erlang.integer_to_list(integer, base)
-  end
-
-  @doc """
-  Returns the greatest common divisor of the two given integers.
-
-  The greatest common divisor (GCD) of `integer1` and `integer2` is the largest positive
-  integer that divides both `integer1` and `integer2` without leaving a remainder.
-
-  By convention, `gcd(0, 0)` returns `0`.
-
-  ## Examples
-
-      iex> Integer.gcd(2, 3)
-      1
-
-      iex> Integer.gcd(8, 12)
-      4
-
-      iex> Integer.gcd(8, -12)
-      4
-
-      iex> Integer.gcd(10, 0)
-      10
-
-      iex> Integer.gcd(7, 7)
-      7
-
-      iex> Integer.gcd(0, 0)
-      0
-
-  """
-  @spec gcd(0, 0) :: 0
-  @spec gcd(integer, integer) :: pos_integer
-  def gcd(integer1, integer2) when is_integer(integer1) and is_integer(integer2) do
-    gcd_positive(abs(integer1), abs(integer2))
-  end
-
-  defp gcd_positive(0, integer2), do: integer2
-  defp gcd_positive(integer1, 0), do: integer1
-  defp gcd_positive(integer1, integer2), do: gcd_positive(integer2, rem(integer1, integer2))
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(integer) :: charlist
-  def to_char_list(integer), do: Integer.to_charlist(integer)
-
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  @doc false
-  @spec to_char_list(integer, 2..36) :: charlist
-  def to_char_list(integer, base), do: Integer.to_charlist(integer, base)
-end

lib/elixir/lib/io.ex

@@ -1,534 +0,0 @@
-defmodule IO do
-  @moduledoc """
-  Functions handling input/output (IO).
-
-  Many functions in this module expect an IO device as an argument.
-  An IO device must be a PID or an atom representing a process.
-  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
-  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,
-  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:
-
-    * `:stdio` - a shortcut for `:standard_io`, which maps to
-      the current `Process.group_leader/0` in Erlang
-
-    * `:stderr` - a shortcut for the named process `:standard_error`
-      provided in Erlang
-
-  IO devices maintain their position, that means subsequent calls to any
-  reading or writing functions will start from the place when the device
-  was last accessed. Position of files can be changed using the
-  `:file.position/2` function.
-
-  """
-
-  @type device :: atom | pid
-  @type nodata :: {:error, term} | :eof
-  @type chardata() :: :unicode.chardata()
-
-  defmacrop is_iodata(data) do
-    quote do
-      is_list(unquote(data)) or is_binary(unquote(data))
-    end
-  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.
-
-  It returns:
-
-    * `data` - the output characters
-
-    * `:eof` - end of file was encountered
-
-    * `{:error, reason}` - other (rare) error condition;
-      for instance, `{:error, :estale}` if reading from an
-      NFS volume
-
-  If `:all` is given, `:eof` is never returned, but an
-  empty string in case the device has reached EOF.
-  """
-  @spec read(device, :all | :line | non_neg_integer) :: chardata | nodata
-  def read(device \\ :stdio, line_or_chars)
-
-  def read(device, :all) do
-    do_read_all(map_dev(device), "")
-  end
-
-  def read(device, :line) do
-    :io.get_line(map_dev(device), '')
-  end
-
-  def read(device, count) when is_integer(count) and count >= 0 do
-    :io.get_chars(map_dev(device), '', count)
-  end
-
-  defp do_read_all(mapped_dev, acc) do
-    case :io.get_line(mapped_dev, "") do
-      line when is_binary(line) -> do_read_all(mapped_dev, acc <> line)
-      :eof -> acc
-      other -> other
-    end
-  end
-
-  @doc """
-  Reads from the IO `device`. The operation is Unicode unsafe.
-
-  The `device` is iterated by the given number of bytes or line by line if
-  `:line` is given.
-  Alternatively, if `:all` is given, then whole `device` is returned.
-
-  It returns:
-
-    * `data` - the output bytes
-
-    * `:eof` - end of file was encountered
-
-    * `{:error, reason}` - other (rare) error condition;
-      for instance, `{:error, :estale}` if reading from an
-      NFS volume
-
-  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
-  as it will return the wrong result.
-  """
-  @spec binread(device, :all | :line | non_neg_integer) :: iodata | nodata
-  def binread(device \\ :stdio, line_or_chars)
-
-  def binread(device, :all) do
-    do_binread_all(map_dev(device), "")
-  end
-
-  def binread(device, :line) do
-    case :file.read_line(map_dev(device)) do
-      {:ok, data} -> data
-      other -> other
-    end
-  end
-
-  def binread(device, count) when is_integer(count) and count >= 0 do
-    case :file.read(map_dev(device), count) do
-      {:ok, data} -> data
-      other -> other
-    end
-  end
-
-  @read_all_size 4096
-  defp do_binread_all(mapped_dev, acc) do
-    case :file.read(mapped_dev, @read_all_size) do
-      {:ok, data} -> do_binread_all(mapped_dev, acc <> data)
-      :eof -> acc
-      other -> other
-    end
-  end
-
-  @doc """
-  Writes `item` to the given `device`.
-
-  By default the `device` is the standard output.
-  It returns `:ok` if it succeeds.
-
-  ## Examples
-
-      IO.write "sample"
-      #=> sample
-
-      IO.write :stderr, "error"
-      #=> error
-
-  """
-  @spec write(device, chardata | String.Chars.t) :: :ok
-  def write(device \\ :stdio, item) do
-    :io.put_chars map_dev(device), to_chardata(item)
-  end
-
-  @doc """
-  Writes `item` as a binary to the given `device`.
-  No Unicode conversion happens.
-  The operation is Unicode unsafe.
-
-  Check `write/2` for more information.
-
-  Note: do not use this function on IO devices in Unicode mode
-  as it will return the wrong result.
-  """
-  @spec binwrite(device, iodata) :: :ok | {:error, term}
-  def binwrite(device \\ :stdio, item) when is_iodata(item) do
-    :file.write map_dev(device), item
-  end
-
-  @doc """
-  Writes `item` to the given `device`, similar to `write/2`,
-  but adds a newline at the end.
-  """
-  @spec puts(device, chardata | String.Chars.t) :: :ok
-  def puts(device \\ :stdio, item) do
-    :io.put_chars map_dev(device), [to_chardata(item), ?\n]
-  end
-
-  @doc """
-  Writes a `message` to stderr, along with the given `stacktrace`.
-
-  This function also notifies the compiler a warning was printed
-  (in case --warnings-as-errors was enabled). It returns `:ok`
-  if it succeeds.
-
-  An empty list can be passed to avoid stacktrace printing.
-
-  ## Examples
-
-      stacktrace = [{MyApp, :main, 1, [file: 'my_app.ex', line: 4]}]
-      IO.warn "variable bar is unused", stacktrace
-      #=> warning: variable bar is unused
-      #=>   my_app.ex:4: MyApp.main/1
-
-  """
-  @spec warn(chardata | String.Chars.t, Exception.stacktrace) :: :ok
-  def warn(message, []) do
-    :elixir_errors.warn([to_chardata(message), ?\n])
-  end
-  def warn(message, stacktrace) when is_list(stacktrace) do
-    formatted = Enum.map_join(stacktrace, "\n  ", &Exception.format_stacktrace_entry(&1))
-    :elixir_errors.warn([to_chardata(message), ?\n, "  ", formatted, ?\n])
-  end
-
-  @doc """
-  Writes a `message` to stderr, along with the current stacktrace.
-
-  It returns `:ok` if it succeeds.
-
-  ## Examples
-
-      IO.warn "variable bar is unused"
-      #=> warning: variable bar is unused
-      #=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4
-
-  """
-  @spec warn(chardata | String.Chars.t) :: :ok
-  def warn(message) do
-    {:current_stacktrace, stacktrace} = Process.info(self(), :current_stacktrace)
-    warn(message, Enum.drop(stacktrace, 2))
-  end
-
-  @doc """
-  Inspects and writes the given `item` to the device.
-
-  It's important to note that it returns the given `item` unchanged.
-  This makes it possible to "spy" on values by inserting an
-  `IO.inspect/2` call almost anywhere in your code, for example,
-  in the middle of a pipeline.
-
-  It enables pretty printing by default with width of
-  80 characters. The width can be changed by explicitly
-  passing the `:width` option.
-
-  The output can be decorated with a label, by providing the `:label`
-  option to easily distinguish it from other `IO.inspect/2` calls.
-  The label will be printed before the inspected `item`.
-
-  See `Inspect.Opts` for a full list of remaining formatting options.
-
-  ## Examples
-
-      IO.inspect <<0, 1, 2>>, width: 40
-
-  Prints:
-
-      <<0, 1, 2>>
-
-  We can use the `:label` option to decorate the output:
-
-      IO.inspect 1..100, label: "a wonderful range"
-
-  Prints:
-
-      a wonderful range: 1..100
-
-  The `:label` option is especially useful with pipelines:
-
-      [1, 2, 3]
-      |> IO.inspect(label: "before")
-      |> Enum.map(&(&1 * 2))
-      |> IO.inspect(label: "after")
-      |> Enum.sum
-
-  Prints:
-
-      before: [1, 2, 3]
-      after: [2, 4, 6]
-
-  """
-  @spec inspect(item, keyword) :: item when item: var
-  def inspect(item, opts \\ []) do
-    inspect :stdio, item, opts
-  end
-
-  @doc """
-  Inspects `item` according to the given options using the IO `device`.
-
-  See `inspect/2` for a full list of options.
-  """
-  @spec inspect(device, item, keyword) :: item when item: var
-  def inspect(device, item, opts) when is_list(opts) do
-    label    = if (label = opts[:label]), do: [to_chardata(label), ": "], else: []
-    opts     = struct(Inspect.Opts, opts)
-    chardata = Inspect.Algebra.format(Inspect.Algebra.to_doc(item, opts), opts.width)
-    puts device, [label, chardata]
-    item
-  end
-
-  @doc """
-  Gets a number of bytes from IO device `:stdio`.
-
-  If `:stdio` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
-  Otherwise, `count` is the number of raw bytes to be retrieved.
-
-  See `IO.getn/3` for a description of return values.
-
-  """
-  @spec getn(chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  @spec getn(device, chardata | String.Chars.t) :: chardata | nodata
-  def getn(prompt, count \\ 1)
-
-  def getn(prompt, count) when is_integer(count) and count > 0 do
-    getn(:stdio, prompt, count)
-  end
-
-  def getn(device, prompt) when not is_integer(prompt) do
-    getn(device, prompt, 1)
-  end
-
-  @doc """
-  Gets a number of bytes from the IO `device`.
-
-  If the IO `device` is a Unicode device, `count` implies
-  the number of Unicode codepoints to be retrieved.
-  Otherwise, `count` is the number of raw bytes to be retrieved.
-
-  It returns:
-
-    * `data` - the input characters
-
-    * `:eof` - end of file was encountered
-
-    * `{:error, reason}` - other (rare) error condition;
-      for instance, `{:error, :estale}` if reading from an
-      NFS volume
-
-  """
-  @spec getn(device, chardata | String.Chars.t, pos_integer) :: chardata | nodata
-  def getn(device, prompt, count) when is_integer(count) and count > 0 do
-    :io.get_chars(map_dev(device), to_chardata(prompt), count)
-  end
-
-  @doc ~S"""
-  Reads a line from the IO `device`.
-
-  It returns:
-
-    * `data` - the characters in the line terminated
-      by a line-feed (LF) or end of file (EOF)
-
-    * `:eof` - end of file was encountered
-
-    * `{:error, reason}` - other (rare) error condition;
-      for instance, `{:error, :estale}` if reading from an
-      NFS volume
-
-  ## Examples
-
-  To display "What is your name?" as a prompt and await user input:
-
-      IO.gets "What is your name?\n"
-
-  """
-  @spec gets(device, chardata | String.Chars.t) :: chardata | nodata
-  def gets(device \\ :stdio, prompt) do
-    :io.get_line(map_dev(device), to_chardata(prompt))
-  end
-
-  @doc """
-  Converts the IO `device` into an `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.
-
-  This reads from the IO as UTF-8. Check out
-  `IO.binstream/2` to handle the IO as a raw binary.
-
-  Note that an IO stream has side effects and every time
-  you go over the stream you may get different results.
-
-  ## Examples
-
-  Here is an example on how we mimic an echo server
-  from the command line:
-
-      Enum.each IO.stream(:stdio, :line), &IO.write(&1)
-
-  """
-  @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
-    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.
-
-  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.
-
-  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
-  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
-    IO.Stream.__build__(map_dev(device), true, line_or_bytes)
-  end
-
-  @doc """
-  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.
-
-  ## Examples
-
-      iex> IO.chardata_to_string([0x00E6, 0x00DF])
-      "æß"
-
-      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
-    string
-  end
-
-  def chardata_to_string(list) when is_list(list) do
-    List.to_string(list)
-  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
-  use `chardata_to_string/1` instead.
-
-  If this function receives a binary, the same binary is returned.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> bin1 = <<1, 2, 3>>
-      iex> bin2 = <<4, 5>>
-      iex> bin3 = <<6>>
-      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>>
-      iex> IO.iodata_to_binary(bin)
-      <<1, 2, 3>>
-
-  """
-  @spec iodata_to_binary(iodata) :: binary
-  def iodata_to_binary(item) do
-    :erlang.iolist_to_binary(item)
-  end
-
-  @doc """
-  Returns the size of an iodata.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> IO.iodata_length([1, 2 | <<3, 4>>])
-      4
-
-  """
-  @spec iodata_length(iodata) :: non_neg_integer
-  def iodata_length(item) do
-    :erlang.iolist_size(item)
-  end
-
-  @doc false
-  def each_stream(device, line_or_codepoints) do
-    case read(device, line_or_codepoints) do
-      :eof ->
-        {:halt, device}
-      {:error, reason} ->
-        raise IO.StreamError, reason: reason
-      data ->
-        {[data], device}
-    end
-  end
-
-  @doc false
-  def each_binstream(device, line_or_chars) do
-    case binread(device, line_or_chars) do
-      :eof ->
-        {:halt, device}
-      {:error, reason} ->
-        raise IO.StreamError, reason: reason
-      data ->
-        {[data], device}
-    end
-  end
-
-  @compile {:inline, map_dev: 1, to_chardata: 1}
-
-  # Map the Elixir names for standard IO and error to Erlang names
-  defp map_dev(:stdio),  do: :standard_io
-  defp map_dev(:stderr), do: :standard_error
-  defp map_dev(other) when is_atom(other) or is_pid(other) or is_tuple(other), do: other
-
-  defp to_chardata(list) when is_list(list), do: list
-  defp to_chardata(other), do: to_string(other)
-end

lib/elixir/lib/io/ansi.ex

@@ -1,252 +0,0 @@
-defmodule IO.ANSI.Sequence do
-  @moduledoc false
-
-  defmacro defsequence(name, code, terminator \\ "m") do
-    quote bind_quoted: [name: name, code: code, terminator: terminator] do
-      def unquote(name)() do
-        "\e[#{unquote(code)}#{unquote(terminator)}"
-      end
-
-      defp format_sequence(unquote(name)) do
-        unquote(name)()
-      end
-    end
-  end
-end
-
-defmodule IO.ANSI do
-  @moduledoc """
-  Functionality to render ANSI escape sequences.
-
-  [ANSI escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)
-  are characters embedded in text used to control formatting, color, and
-  other output options on video text terminals.
-  """
-
-  import IO.ANSI.Sequence
-
-  @type ansicode :: atom
-  @type 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.
-
-  This function simply reads the configuration value for
-  `:ansi_enabled` in the `:elixir` application. The value is by
-  default `false` unless Elixir can detect during startup that
-  both `stdout` and `stderr` are terminals.
-  """
-  @spec enabled? :: boolean
-  def enabled? do
-    Application.get_env(:elixir, :ansi_enabled, false)
-  end
-
-  @doc "Sets foreground color."
-  @spec color(0..255) :: String.t
-  def color(code) when code in 0..255, do: "\e[38;5;#{code}m"
-
-  @doc ~S"""
-  Sets the foreground color from individual RGB values.
-
-  Valid values for each color are in the range 0 to 5.
-  """
-  @spec color(0..5, 0..5, 0..5) :: String.t
-  def color(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color(16 + (36 * r) + (6 * g) + b)
-  end
-
-  @doc "Sets background color."
-  @spec color_background(0..255) :: String.t
-  def color_background(code) when code in 0..255, do: "\e[48;5;#{code}m"
-
-  @doc ~S"""
-  Sets the background color from individual RGB values.
-
-  Valid values for each color are in the range 0 to 5.
-  """
-  @spec color_background(0..5, 0..5, 0..5) :: String.t
-  def color_background(r, g, b) when r in 0..5 and g in 0..5 and b in 0..5 do
-    color_background(16 + (36 * r) + (6 * g) + b)
-  end
-
-  @doc "Resets all attributes."
-  defsequence :reset, 0
-
-  @doc "Bright (increased intensity) or bold."
-  defsequence :bright, 1
-
-  @doc "Faint (decreased intensity). Not widely supported."
-  defsequence :faint, 2
-
-  @doc "Italic: on. Not widely supported. Sometimes treated as inverse."
-  defsequence :italic, 3
-
-  @doc "Underline: single."
-  defsequence :underline, 4
-
-  @doc "Blink: slow. Less than 150 per minute."
-  defsequence :blink_slow, 5
-
-  @doc "Blink: rapid. MS-DOS ANSI.SYS; 150 per minute or more; not widely supported."
-  defsequence :blink_rapid, 6
-
-  @doc "Image: negative. Swap foreground and background."
-  defsequence :inverse, 7
-
-  @doc "Image: negative. Swap foreground and background."
-  defsequence :reverse, 7
-
-  @doc "Conceal. Not widely supported."
-  defsequence :conceal, 8
-
-  @doc "Crossed-out. Characters legible, but marked for deletion. Not widely supported."
-  defsequence :crossed_out, 9
-
-  @doc "Sets primary (default) font."
-  defsequence :primary_font, 10
-
-  for font_n <- [1, 2, 3, 4, 5, 6, 7, 8, 9] do
-    @doc "Sets alternative font #{font_n}."
-    defsequence :"font_#{font_n}", font_n + 10
-  end
-
-  @doc "Normal color or intensity."
-  defsequence :normal, 22
-
-  @doc "Not italic."
-  defsequence :not_italic, 23
-
-  @doc "Underline: none."
-  defsequence :no_underline, 24
-
-  @doc "Blink: off."
-  defsequence :blink_off, 25
-
-  @doc "Image: positive. Normal foreground and background."
-  defsequence :inverse_off, 27
-
-  @doc "Image: positive. Normal foreground and background."
-  defsequence :reverse_off, 27
-
-  colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
-
-  for {color, code} <- Enum.with_index(colors) do
-    @doc "Sets foreground color to #{color}."
-    defsequence color, code + 30
-
-    @doc "Sets foreground color to light #{color}."
-    defsequence :"light_#{color}", code + 90
-
-    @doc "Sets background color to #{color}."
-    defsequence :"#{color}_background", code + 40
-
-    @doc "Sets background color to light #{color}."
-    defsequence :"light_#{color}_background", code + 100
-  end
-
-  @doc "Default text color."
-  defsequence :default_color, 39
-
-  @doc "Default background color."
-  defsequence :default_background, 49
-
-  @doc "Framed."
-  defsequence :framed, 51
-
-  @doc "Encircled."
-  defsequence :encircled, 52
-
-  @doc "Overlined."
-  defsequence :overlined, 53
-
-  @doc "Not framed or encircled."
-  defsequence :not_framed_encircled, 54
-
-  @doc "Not overlined."
-  defsequence :not_overlined, 55
-
-  @doc "Sends cursor home."
-  defsequence :home, "", "H"
-
-  @doc "Clears screen."
-  defsequence :clear, "2", "J"
-
-  @doc "Clears line."
-  defsequence :clear_line, "2", "K"
-
-  defp format_sequence(other) do
-    raise ArgumentError, "invalid ANSI sequence specification: #{inspect other}"
-  end
-
-  @doc ~S"""
-  Formats a chardata-like argument by converting named ANSI sequences into actual
-  ANSI codes.
-
-  The named sequences are represented by atoms.
-
-  It will also append an `IO.ANSI.reset/0` to the chardata when a conversion is
-  performed. If you don't want this behaviour, use `format_fragment/2`.
-
-  An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When `false`, no ANSI codes will emitted.
-  By default checks if ANSI is enabled using the `enabled?/0` function.
-
-  ## Examples
-
-      iex> IO.ANSI.format(["Hello, ", :red, :bright, "world!"], true)
-      [[[[[[], "Hello, "] | "\e[31m"] | "\e[1m"], "world!"] | "\e[0m"]
-
-  """
-  def format(chardata, emit? \\ enabled?()) when is_boolean(emit?) do
-    do_format(chardata, [], [], emit?, :maybe)
-  end
-
-  @doc ~S"""
-  Formats a chardata-like argument by converting named ANSI sequences into actual
-  ANSI codes.
-
-  The named sequences are represented by atoms.
-
-  An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When `false`, no ANSI codes will emitted.
-  By default checks if ANSI is enabled using the `enabled?/0` function.
-
-  ## Examples
-
-      iex> IO.ANSI.format_fragment([:bright, 'Word'], true)
-      [[[[[[] | "\e[1m"], 87], 111], 114], 100]
-
-  """
-  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)
-  end
-
-  defp do_format(term, rem, acc, true, append_reset) when is_atom(term) do
-    do_format([], rem, [acc | format_sequence(term)], true, !!append_reset)
-  end
-
-  defp do_format(term, rem, acc, false, append_reset) when is_atom(term) 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)
-  end
-
-  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
-    acc
-  end
-end

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

@@ -1,597 +0,0 @@
-defmodule IO.ANSI.Docs do
-  @moduledoc false
-
-  @bullets [?*, ?-, ?+]
-  @spaces [" ", "\n", "\t"]
-
-  @doc """
-  The default options used by this module.
-
-  The supported values are:
-
-    * `:enabled`           - toggles coloring on and off (true)
-    * `:doc_bold`          - bold text (bright)
-    * `:doc_code`          - code blocks (cyan)
-    * `:doc_headings`      - h1, h2, h3, h4, h5, h6 headings (yellow)
-    * `:doc_inline_code`   - inline code (cyan)
-    * `:doc_table_heading` - style for table headings
-    * `:doc_title`         - top level heading (reverse, yellow)
-    * `:doc_underline`     - underlined text (underline)
-    * `:width`             - the width to format the text (80)
-
-  Values for the color settings are strings with
-  comma-separated ANSI values.
-  """
-  def default_options do
-    [enabled:           true,
-     doc_bold:          [:bright],
-     doc_code:          [:cyan],
-     doc_headings:      [:yellow],
-     doc_inline_code:   [:cyan],
-     doc_table_heading: [:reverse],
-     doc_title:         [:reverse, :yellow],
-     doc_underline:     [:underline],
-     width:             80]
-  end
-
-  @doc """
-  Prints the head of the documentation (i.e. the function signature).
-
-  See `default_options/0` for docs on the supported options.
-  """
-  def print_heading(heading, options \\ []) do
-    IO.puts IO.ANSI.reset
-    options = Keyword.merge(default_options(), options)
-    width   = options[:width]
-    padding = div(width + String.length(heading), 2)
-    heading = heading |> String.pad_leading(padding) |> String.pad_trailing(width)
-    write(:doc_title, heading, options)
-    newline_after_block()
-  end
-
-  @doc """
-  Prints the documentation body.
-
-  In addition to the printing string, takes a set of options
-  defined in `default_options/1`.
-  """
-  def print(doc, options \\ []) do
-    options = Keyword.merge(default_options(), options)
-    doc
-    |> String.split(["\r\n", "\n"], trim: false)
-    |> Enum.map(&String.trim_trailing/1)
-    |> process([], "", options)
-  end
-
-  defp process([], text, indent, options) do
-    write_text(text, indent, options)
-  end
-
-  defp process(["# " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-  defp process(["## " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-  defp process(["### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-  defp process(["#### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-  defp process(["##### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-  defp process(["###### " <> _ = heading | rest], text, indent, options) do
-    write_heading(heading, rest, text, indent, options)
-  end
-
-  defp process(["" | rest], text, indent, options) do
-    write_text(text, indent, options)
-    process(rest, [], indent, options)
-  end
-
-  defp process(["    " <> line | rest], text, indent, options) do
-    write_text(text, indent, options)
-    process_code(rest, [line], indent, options)
-  end
-
-  defp process(["```" <> _line | rest], text, indent, options) do
-    process_fenced_code_block(rest, text, indent, options, _delimiter = "```")
-  end
-
-  defp process(["~~~" <> _line | rest], text, indent, options) do
-    process_fenced_code_block(rest, text, indent, options, _delimiter = "~~~")
-  end
-
-  defp process(all = [line | rest], text, indent, options) do
-    {stripped, count} = strip_spaces(line, 0, :infinity)
-    cond do
-      link_label?(stripped, count) ->
-        write_text([line], indent, options, true)
-        process(rest, text, indent, options)
-      table_line?(stripped) and rest != [] and table_line?(hd(rest)) ->
-        write_text(text, indent, options)
-        process_table(all, indent, options)
-      true ->
-        process_rest(stripped, rest, count, text, indent, options)
-    end
-  end
-
-  ## Headings
-
-  defp write_heading(heading, rest, text, indent, options) do
-    write_text(text, indent, options)
-    write(:doc_headings, heading, options)
-    newline_after_block()
-    process(rest, [], "", options)
-  end
-
-  ## Lists
-
-  defp process_rest(stripped, rest, count, text, indent, options) do
-    case stripped do
-      <<bullet, ?\s, item::binary>> when bullet in @bullets ->
-        write_text(text, indent, options)
-        process_list("• ", item, rest, count, indent, options)
-      <<d1, ?., ?\s, item::binary>> when d1 in ?0..?9 ->
-        write_text(text, indent, options)
-        process_list(<<d1, ?., ?\s>>, item, rest, count, indent, options)
-      <<d1, d2, ?., ?\s, item::binary>> when d1 in ?0..?9 and d2 in ?0..?9 ->
-        write_text(text, indent, options)
-        process_list(<<d1, d2, ?., ?\s>>, item, rest, count, indent, options)
-      _ ->
-        process(rest, [stripped | text], indent, options)
-    end
-  end
-
-  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
-    new_indent = indent <> String.duplicate(" ", String.length(entry))
-
-    {contents, rest, done} = process_list_next(rest, count, byte_size(new_indent), [])
-    process(contents, [indent <> entry <> line, :no_wrap], new_indent, options)
-
-    if done, do: newline_after_block()
-    process(rest, [], indent, options)
-  end
-
-  defp process_list_next([line | rest], count, max, acc) do
-    {stripped, next_count} = strip_spaces(line, 0, max)
-    case process_list_next_kind(stripped, rest, count, next_count) do
-      :next -> process_list_next(rest, count, max, [stripped | acc])
-      :done -> {Enum.reverse(acc), [line | rest], true}
-      :list -> {Enum.reverse(acc), [line | rest], false}
-    end
-  end
-
-  defp process_list_next([], _count, _max, acc) do
-    {Enum.reverse(acc), [], true}
-  end
-
-  defp process_list_next_kind(stripped, rest, count, next_count) do
-    case {stripped, rest} do
-      {<<bullet, ?\s, _::binary>>, _} when bullet in @bullets and next_count <= count ->
-        :list
-      {<<d1, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and next_count <= count ->
-        :list
-      {<<d1, d2, ?., ?\s, _::binary>>, _} when d1 in ?0..?9 and d2 in ?0..?9 and next_count <= count ->
-        :list
-      {"", [" " <> _ | _]} ->
-        :next
-      {"", _} ->
-        :done
-      _ ->
-        :next
-    end
-  end
-
-  ## Text
-
-  defp write_text(text, indent, options) do
-    case Enum.reverse(text) do
-      [:no_wrap | rest] -> write_text(rest, indent, options, true)
-      rest -> write_text(rest, indent, options, false)
-    end
-  end
-
-  defp write_text([], _indent, _options, _no_wrap) do
-    :ok
-  end
-
-  defp write_text(lines, indent, options, no_wrap) do
-    lines
-    |> Enum.join(" ")
-    |> handle_links
-    |> handle_inline(options)
-    |> String.split(@spaces)
-    |> write_with_wrap(options[:width] - byte_size(indent), indent, no_wrap)
-
-    unless no_wrap, do: newline_after_block()
-  end
-
-  ## Code blocks
-
-  defp process_code([], code, indent, options) do
-    write_code(code, indent, options)
-  end
-
-  # Blank line between code blocks
-  defp process_code(["", "    " <> line | rest], code, indent, options) do
-    process_code(rest, [line, "" | code], indent, options)
-  end
-
-  defp process_code(["    " <> line | rest], code, indent, options) do
-    process_code(rest, [line | code], indent, options)
-  end
-
-  defp process_code(rest, code, indent, options) do
-    write_code(code, indent, options)
-    process(rest, [], indent, options)
-  end
-
-  defp process_fenced_code_block(rest, text, indent, options, delimiter) do
-    write_text(text, indent, options)
-    process_fenced_code(rest, [], indent, options, delimiter)
-  end
-
-  defp process_fenced_code([], code, indent, options, _delimiter) do
-    write_code(code, indent, options)
-  end
-
-  defp process_fenced_code([line | rest], code, indent, options, delimiter) do
-    if line === delimiter do
-      process_code(rest, code, indent, options)
-    else
-      process_fenced_code(rest, [line | code], indent, options, delimiter)
-    end
-  end
-
-  defp write_code(code, indent, options) do
-    write(:doc_code, "#{indent}    #{Enum.join(Enum.reverse(code), "\n#{indent}    ")}", options)
-    newline_after_block()
-  end
-
-  ## Tables
-
-  defp process_table(lines, indent, options) do
-    {table, rest} = Enum.split_while(lines, &table_line?/1)
-    table_lines(table, options)
-    newline_after_block()
-    process(rest, [], indent, options)
-  end
-
-  defp table_lines(lines, options) do
-    lines = Enum.map(lines, &split_into_columns(&1, options))
-    count = Enum.map(lines, &length/1) |> Enum.max
-    lines = Enum.map(lines, &pad_to_number_of_columns(&1, count))
-
-    widths =
-      for line <- lines do
-        if table_header?(line) do
-          for _ <- line, do: 0
-        else
-          for {_col, length} <- line, do: length
-        end
-      end
-
-    col_widths = Enum.reduce(widths,
-                             List.duplicate(0, count),
-                             &max_column_widths/2)
-
-    render_table(lines, col_widths, options)
-  end
-
-  defp split_into_columns(line, options) do
-    line
-    |> String.trim("|")
-    |> String.trim()
-    |> String.split(" | ")
-    |> Enum.map(&render_column(&1, options))
-  end
-
-  defp render_column(col, options) do
-    col =
-      col
-      |> String.replace("\\\|", "|")
-      |> String.trim()
-      |> handle_links
-      |> handle_inline(options)
-    {col, length_without_escape(col, 0)}
-  end
-
-  defp pad_to_number_of_columns(cols, col_count),
-    do: cols ++ List.duplicate({"", 0}, col_count - length(cols))
-
-  defp max_column_widths(cols, widths),
-    do: Enum.zip(cols, widths) |> Enum.map(fn {a, b} -> max(a, b) end)
-
-  # If second line is heading separator, use the heading style on the first
-  defp render_table([first, second | rest], widths, options) do
-    combined = Enum.zip(first, widths)
-    if table_header?(second) do
-      alignments = Enum.map(second, &column_alignment/1)
-      options = Keyword.put_new(options, :alignments, alignments)
-      draw_table_row(combined, options, :heading)
-      render_table(rest, widths, options)
-    else
-      draw_table_row(combined, options)
-      render_table([second | rest], widths, options)
-    end
-  end
-
-  defp render_table([first | rest], widths, options) do
-    combined = Enum.zip(first, widths)
-    draw_table_row(combined, options)
-    render_table(rest, widths, options)
-  end
-
-  defp render_table([], _, _),
-    do: nil
-
-  defp column_alignment({line, _}) do
-    cond do
-      String.starts_with?(line, ":") and String.ends_with?(line, ":") -> :center
-      String.ends_with?(line, ":") -> :right
-      true -> :left
-    end
-  end
-
-  defp table_header?(row) do
-    Enum.all?(row, fn {col, _} -> table_header_column?(col) end)
-  end
-
-  defp table_header_column?(":" <> row), do: table_header_contents?(row)
-  defp table_header_column?(row), do: table_header_contents?(row)
-
-  defp table_header_contents?("-" <> row), do: table_header_contents?(row)
-  defp table_header_contents?(":"), do: true
-  defp table_header_contents?(""), do: true
-  defp table_header_contents?(_), do: false
-
-  defp draw_table_row(cols_and_widths, options, heading \\ false) do
-    default_alignments = List.duplicate(:left, length(cols_and_widths))
-    alignments = Keyword.get(options, :alignments, default_alignments)
-
-    columns =
-      cols_and_widths
-      |> Enum.zip(alignments)
-      |> Enum.map_join(" | ", &generate_table_cell/1)
-
-    if heading do
-      write(:doc_table_heading, columns, options)
-    else
-      IO.puts columns
-    end
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :center}) do
-    pad = if rem(length, 2) == 0, do: 1, else: rem(width, 2)
-    spaces = div(width, 2) - div(length, 2)
-    String.duplicate(" ", spaces) <> col <> String.duplicate(" ", spaces + pad)
-  end
-
-  defp generate_table_cell({{{col, length}, width}, :right}) do
-    String.duplicate(" ", width - length) <> col
-  end
-
-  defp generate_table_cell({{{col, length}, width}, _}) do
-    col <> String.duplicate(" ", width - length)
-  end
-
-  defp table_line?(line) do
-    line =~ " | "
-  end
-
-  ## Helpers
-
-  defp link_label?("[" <> rest, count) when count <= 3, do: link_label?(rest)
-  defp link_label?(_, _), do: false
-
-  defp link_label?("]: " <> _), do: true
-  defp link_label?("]" <> _), do: false
-  defp link_label?(""), do: false
-  defp link_label?(<<_>> <> rest), do: link_label?(rest)
-
-  defp strip_spaces(" " <> line, acc, max) when acc < max,
-    do: strip_spaces(line, acc + 1, max)
-  defp strip_spaces(rest, acc, _max),
-    do: {rest, acc}
-
-  defp write(style, string, options) do
-    IO.puts [color(style, options), string, IO.ANSI.reset]
-  end
-
-  defp write_with_wrap([], _available, _indent, _first) do
-    :ok
-  end
-
-  defp write_with_wrap(words, available, indent, first) do
-    {words, rest} = take_words(words, available, [])
-    IO.puts (if first, do: "", else: indent) <> Enum.join(words, " ")
-    write_with_wrap(rest, available, indent, false)
-  end
-
-  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])
-
-      # No space but we got no words
-      acc == [] ->
-        {[word], words}
-
-      # Otherwise
-      true ->
-        {Enum.reverse(acc), [word | words]}
-    end
-  end
-
-  defp take_words([], _available, acc) do
-    {Enum.reverse(acc), []}
-  end
-
-  defp length_without_escape(<<?\e, ?[, _, _, ?m>> <> rest, count) do
-    length_without_escape(rest, count)
-  end
-
-  defp length_without_escape(<<?\e, ?[, _, ?m>> <> rest, count) do
-    length_without_escape(rest, count)
-  end
-
-  defp length_without_escape(rest, count) do
-    case String.next_grapheme(rest) do
-      {_, rest} -> length_without_escape(rest, count + 1)
-      nil -> count
-    end
-  end
-
-  defp handle_links(text) do
-    text
-    |> remove_square_brackets_in_link
-    |> escape_underlines_in_link
-  end
-
-  defp escape_underlines_in_link(text) do
-    ~r{https?\S*}
-    |> Regex.recompile!
-    |> Regex.replace(text, &String.replace(&1, "_", "\\_"))
-  end
-
-  defp remove_square_brackets_in_link(text) do
-    ~r{\[(.*?)\]\((.*?)\)}
-    |> Regex.recompile!
-    |> Regex.replace(text, "\\1 (\\2)")
-  end
-
-  # We have four entries: **, *, _ and `.
-  #
-  # The first three behave the same while the last one is simpler
-  # when it comes to delimiters. But, since the first has two
-  # characters, we need to handle 3 cases:
-  #
-  # 1. **
-  # 2. _ and *
-  # 3. `
-  #
-  # Where the first two should have the same code but match differently.
-  @single [?_, ?*]
-
-  # Characters that can mark the beginning or the end of a word.
-  # Only support the most common ones at this moment.
-  @delimiters [?\s, ?', ?", ?!, ?@, ?#, ?$, ?%, ?^, ?&, ?-, ?+, ?(, ?), ?[, ?], ?{, ?}, ?<, ?>, ?.]
-
-  # Inline start
-
-  defp handle_inline(<<?*, ?*, rest::binary>>, options) do
-    handle_inline(rest, ?d, ["**"], [], options)
-  end
-
-  defp handle_inline(<<mark, rest::binary>>, options) when mark in @single do
-    handle_inline(rest, mark, [<<mark>>], [], options)
-  end
-
-  defp handle_inline(rest, options) do
-    handle_inline(rest, nil, [], [], options)
-  end
-
-  # Inline delimiters
-
-  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)
-  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)
-  end
-
-  defp handle_inline(<<?`, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" do
-    handle_inline(rest, ?`, ["`"], [Enum.reverse(buffer) | acc], options)
-  end
-
-  # Clauses for handling escape
-
-  defp handle_inline(<<?\\, ?\\, ?*, ?*, rest::binary>>, nil, buffer, acc, options)
-      when rest != "" do
-    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)
-  end
-
-  defp handle_inline(<<?\\, ?\\, rest::binary>>, limit, buffer, acc, options) do
-    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)
-  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)
-  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)
-  end
-
-  defp handle_inline(<<?*, ?*, rest::binary>>, ?d, buffer, acc, options)
-      when rest == "" do
-    handle_inline(<<>>, nil, [], [inline_buffer(buffer, options) | acc], options)
-  end
-
-  defp handle_inline(<<mark, rest::binary>>, mark, buffer, acc, options)
-      when rest == "" and mark in @single do
-    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)
-  end
-
-  # Catch all
-
-  defp handle_inline(<<char, rest::binary>>, mark, buffer, acc, options) do
-    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])
-  end
-
-  defp inline_buffer(buffer, options) do
-    [h | t] = Enum.reverse([IO.ANSI.reset | buffer])
-    [color_for(h, options) | t]
-  end
-
-  defp color_for(mark, colors) do
-    case mark do
-      "`"  -> color(:doc_inline_code, colors)
-      "_"  -> color(:doc_underline, colors)
-      "*"  -> color(:doc_bold, colors)
-      "**" -> color(:doc_bold, colors)
-    end
-  end
-
-  defp color(style, colors) do
-    color = colors[style]
-    IO.ANSI.format_fragment(color, colors[:enabled])
-  end
-
-  defp newline_after_block, do: IO.puts(IO.ANSI.reset)
-end

lib/elixir/lib/io/stream.ex

@@ -1,70 +0,0 @@
-defmodule IO.StreamError do
-  defexception [:reason, :message]
-
-  def exception(opts) do
-    reason    = opts[:reason]
-    formatted = IO.iodata_to_binary(:file.format_error(reason))
-    %IO.StreamError{message: "error during streaming: #{formatted}", reason: reason}
-  end
-end
-
-defmodule IO.Stream do
-  @moduledoc """
-  Defines an `IO.Stream` struct returned by `IO.stream/2` and `IO.binstream/2`.
-
-  The following fields are public:
-
-    * `device`        - the IO device
-    * `raw`           - a boolean indicating if bin functions should be used
-    * `line_or_bytes` - if reading should read lines or a given 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
-
-  @type t :: %__MODULE__{}
-
-  @doc false
-  def __build__(device, raw, line_or_bytes) do
-    %IO.Stream{device: device, raw: raw, line_or_bytes: line_or_bytes}
-  end
-
-  defimpl Collectable do
-    def into(%{device: device, raw: raw} = stream) do
-      {:ok, into(stream, device, raw)}
-    end
-
-    defp into(stream, device, raw) do
-      fn
-        :ok, {:cont, x} ->
-          case raw do
-            true  -> IO.binwrite(device, x)
-            false -> IO.write(device, x)
-          end
-        :ok, _ -> stream
-      end
-    end
-  end
-
-  defimpl Enumerable do
-    def reduce(%{device: device, raw: raw, line_or_bytes: line_or_bytes}, acc, fun) do
-      next_fun =
-        case raw do
-          true  -> &IO.each_binstream(&1, line_or_bytes)
-          false -> &IO.each_stream(&1, line_or_bytes)
-        end
-      Stream.resource(fn -> device end, next_fun, &(&1)).(acc, fun)
-    end
-
-    def count(_stream) do
-      {:error, __MODULE__}
-    end
-
-    def member?(_stream, _term) do
-      {:error, __MODULE__}
-    end
-  end
-end

lib/elixir/lib/kernel/cli.ex

@@ -1,484 +0,0 @@
-defmodule Kernel.CLI do
-  @moduledoc false
-
-  @blank_config %{commands: [], output: ".", compile: [],
-                  halt: true, compiler_options: [], errors: [],
-                  pa: [], pz: [], verbose_compile: false}
-
-  @doc """
-  This is the API invoked by Elixir boot process.
-  """
-  def main(argv) do
-    argv = for arg <- argv, do: IO.chardata_to_string(arg)
-
-    {config, argv} = parse_argv(argv)
-    System.argv(argv)
-
-    run fn _ ->
-      errors = process_commands(config)
-
-      if errors != [] do
-        Enum.each(errors, &IO.puts(:stderr, &1))
-        System.halt(1)
-      end
-    end, config.halt
-  end
-
-  @doc """
-  Runs the given function by catching any failure
-  and printing them to stdout. `at_exit` hooks are
-  also invoked before exiting.
-
-  This function is used by Elixir's CLI and also
-  by escripts generated by Elixir.
-  """
-  def run(fun, halt \\ true) do
-    {ok_or_shutdown, status} = exec_fun(fun, {:ok, 0})
-    if ok_or_shutdown == :shutdown or halt do
-      {_, status} = at_exit({ok_or_shutdown, status})
-
-      # Ensure Logger messages are flushed before halting
-      case :erlang.whereis(Logger) do
-        pid when is_pid(pid) -> Logger.flush()
-        _ -> :ok
-      end
-
-      System.halt(status)
-    end
-  end
-
-  @doc false
-  def parse_argv(argv) do
-    parse_argv(argv, @blank_config)
-  end
-
-  @doc false
-  def process_commands(config) do
-    results = Enum.map(Enum.reverse(config.commands), &process_command(&1, config))
-    errors  = for {:error, msg} <- results, do: msg
-    Enum.reverse(config.errors, errors)
-  end
-
-  @doc false
-  def format_error(kind, reason, stacktrace) do
-    {blamed, stacktrace} = Exception.blame(kind, reason, stacktrace)
-    iodata =
-      case blamed do
-        %FunctionClauseError{} ->
-          [Exception.format_banner(kind, reason, stacktrace),
-           pad(FunctionClauseError.blame(blamed, &inspect/1, &blame_match/2))]
-        _ ->
-          Exception.format_banner(kind, blamed, stacktrace)
-      end
-    [iodata, ?\n, Exception.format_stacktrace(prune_stacktrace(stacktrace))]
-  end
-
-  ## Helpers
-
-  defp at_exit(res) do
-    hooks = :elixir_config.get_and_put(:at_exit, [])
-    res = Enum.reduce(hooks, res, &exec_fun/2)
-    if hooks == [], do: res, else: at_exit(res)
-  end
-
-  defp exec_fun(fun, res) when is_function(fun, 1) and is_tuple(res) do
-    parent = self()
-
-    {pid, ref} =
-      spawn_monitor(fn ->
-        try do
-          fun.(elem(res, 1))
-        catch
-          :exit, {:shutdown, int} when is_integer(int) ->
-            send parent, {self(), {:shutdown, int}}
-            exit({:shutdown, int})
-          :exit, reason
-              when reason == :normal
-              when reason == :shutdown
-              when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown ->
-            send parent, {self(), {:shutdown, 0}}
-            exit(reason)
-          kind, reason ->
-            stack = System.stacktrace
-            print_error(kind, reason, stack)
-            send parent, {self(), {:shutdown, 1}}
-            exit(to_exit(kind, reason, stack))
-        else
-          _ ->
-            send parent, {self(), res}
-        end
-      end)
-
-    receive do
-      {^pid, res} ->
-        :erlang.demonitor(ref, [:flush])
-        res
-      {:DOWN, ^ref, _, _, other} ->
-        print_error({:EXIT, pid}, other, [])
-        {:shutdown, 1}
-    end
-  end
-
-  defp to_exit(:throw, reason, stack), do: {{:nocatch, reason}, stack}
-  defp to_exit(:error, reason, stack), do: {reason, stack}
-  defp to_exit(:exit, reason, _stack), do: reason
-
-  defp shared_option?(list, config, callback) do
-    case parse_shared(list, config) do
-      {[h | hs], _} when h == hd(list) ->
-        new_config = %{config | errors: ["#{h} : Unknown option" | config.errors]}
-        callback.(hs, new_config)
-      {new_list, new_config} ->
-        callback.(new_list, new_config)
-    end
-  end
-
-  ## Error handling
-
-  defp print_error(kind, reason, stacktrace) do
-    IO.write :stderr, format_error(kind, reason, stacktrace)
-  end
-
-  defp blame_match(%{match?: true, node: node}, _),
-    do: blame_ansi(:normal, "+", node)
-  defp blame_match(%{match?: false, node: node}, _),
-    do: blame_ansi(:red, "-", node)
-  defp blame_match(_, string),
-    do: string
-
-  defp blame_ansi(color, no_ansi, node) do
-    if IO.ANSI.enabled? do
-      [color | Macro.to_string(node)]
-      |> IO.ANSI.format(true)
-      |> IO.iodata_to_binary()
-    else
-      no_ansi <> Macro.to_string(node) <> no_ansi
-    end
-  end
-
-  defp pad(string) do
-    "    " <> String.replace(string, "\n", "\n    ")
-  end
-
-  @elixir_internals [:elixir, :elixir_expand, :elixir_compiler, :elixir_module,
-                     :elixir_clauses, :elixir_lexical, :elixir_def, :elixir_map,
-                     :elixir_erl, :elixir_erl_clauses, :elixir_erl_pass, Kernel.ErrorHandler]
-
-  defp prune_stacktrace([{mod, _, _, _} | t]) when mod in @elixir_internals do
-    prune_stacktrace(t)
-  end
-
-  defp prune_stacktrace([{__MODULE__, :wrapper, 1, _} | _]) do
-    []
-  end
-
-  defp prune_stacktrace([h | t]) do
-    [h | prune_stacktrace(t)]
-  end
-
-  defp prune_stacktrace([]) do
-    []
-  end
-
-  # Parse shared options
-
-  defp parse_shared([opt | _t], _config) when opt in ["-v", "--version"] do
-    if function_exported?(IEx, :started?, 0) and IEx.started? do
-      IO.puts "IEx " <> System.build_info[:build]
-    else
-      IO.puts :erlang.system_info(:system_version)
-      IO.puts "Elixir " <> System.build_info[:build]
-    end
-
-    System.halt 0
-  end
-
-  defp parse_shared(["-pa", h | t], config) do
-    paths = expand_code_path(h)
-    Enum.each(paths, &:code.add_patha/1)
-    parse_shared t, %{config | pa: config.pa ++ paths}
-  end
-
-  defp parse_shared(["-pz", h | t], config) do
-    paths = expand_code_path(h)
-    Enum.each(paths, &:code.add_pathz/1)
-    parse_shared t, %{config | pz: config.pz ++ paths}
-  end
-
-  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
-    parse_shared t, %{config | halt: false}
-  end
-
-  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
-    parse_shared t, %{config | commands: [{:require, h} | config.commands]}
-  end
-
-  defp parse_shared(["-pr", h | t], config) do
-    parse_shared t, %{config | commands: [{:parallel_require, h} | config.commands]}
-  end
-
-  defp parse_shared([erl, _ | t], config) when erl in ["--erl", "--sname", "--name", "--cookie", "--logger-otp-reports", "--logger-sasl-reports"] do
-    parse_shared t, config
-  end
-
-  defp parse_shared([erl | t], config) when erl in ["--detached", "--hidden", "--werl"] do
-    parse_shared t, config
-  end
-
-  defp parse_shared(list, config) do
-    {list, config}
-  end
-
-  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)
-    end
-  end
-
-  # Process init options
-
-  defp parse_argv(["--" | t], config) do
-    {config, t}
-  end
-
-  defp parse_argv(["+elixirc" | t], config) do
-    parse_compiler t, config
-  end
-
-  defp parse_argv(["+iex" | t], config) do
-    parse_iex t, config
-  end
-
-  defp parse_argv(["-S", h | t], config) do
-    {%{config | commands: [{:script, h} | config.commands]}, t}
-  end
-
-  defp parse_argv([h | t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_argv(&1, &2)
-      _ ->
-        if Keyword.has_key?(config.commands, :eval) do
-          {config, list}
-        else
-          {%{config | commands: [{:file, h} | config.commands]}, t}
-        end
-    end
-  end
-
-  defp parse_argv([], config) do
-    {config, []}
-  end
-
-  # Parse compiler options
-
-  defp parse_compiler(["--" | t], config) do
-    {config, t}
-  end
-
-  defp parse_compiler(["-o", h | t], config) do
-    parse_compiler t, %{config | output: h}
-  end
-
-  defp parse_compiler(["--no-docs" | t], config) do
-    parse_compiler t, %{config | compiler_options: [{:docs, false} | config.compiler_options]}
-  end
-
-  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
-    parse_compiler t, %{config | compiler_options: [{:ignore_module_conflict, true} | config.compiler_options]}
-  end
-
-  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
-    parse_compiler t, %{config | verbose_compile: true}
-  end
-
-  defp parse_compiler([h | t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_compiler(&1, &2)
-      _ ->
-        pattern = if File.dir?(h), do: "#{h}/**/*.ex", else: h
-        parse_compiler t, %{config | compile: [pattern | config.compile]}
-    end
-  end
-
-  defp parse_compiler([], config) do
-    {%{config | commands: [{:compile, config.compile} | config.commands]}, []}
-  end
-
-  # Parse IEx options
-
-  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
-    parse_iex t, config
-  end
-
-  defp parse_iex([opt, _ | t], config) when opt in ["--remsh"] do
-    parse_iex t, config
-  end
-
-  defp parse_iex(["-S", h | t], config) do
-    {%{config | commands: [{:script, h} | config.commands]}, t}
-  end
-
-  defp parse_iex([h | t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, &parse_iex(&1, &2)
-      _ ->
-        {%{config | commands: [{:file, h} | config.commands]}, t}
-    end
-  end
-
-  defp parse_iex([], config) do
-    {config, []}
-  end
-
-  # Process commands
-
-  defp process_command({:cookie, h}, _config) do
-    if Node.alive? do
-      wrapper fn -> Node.set_cookie(String.to_atom(h)) end
-    else
-      {:error, "--cookie : Cannot set cookie if the node is not alive (set --name or --sname)"}
-    end
-  end
-
-  defp process_command({:eval, expr}, _config) when is_binary(expr) do
-    wrapper fn -> Code.eval_string(expr, []) end
-  end
-
-  defp process_command({:app, app}, _config) when is_binary(app) do
-    case Application.ensure_all_started(String.to_atom(app)) do
-      {:error, {app, reason}} ->
-        {:error, "--app : Could not start application #{app}: " <>
-          Application.format_error(reason)}
-      {:ok, _} ->
-        :ok
-    end
-  end
-
-  defp process_command({:script, file}, _config) when is_binary(file) do
-    if exec = find_elixir_executable(file) do
-      wrapper fn -> Code.require_file(exec) end
-    else
-      {:error, "-S : Could not find executable #{file}"}
-    end
-  end
-
-  defp process_command({:file, file}, _config) when is_binary(file) do
-    if File.regular?(file) do
-      wrapper fn -> Code.require_file(file) end
-    else
-      {:error, "No file named #{file}"}
-    end
-  end
-
-  defp process_command({:require, pattern}, _config) when is_binary(pattern) do
-    files = filter_patterns(pattern)
-
-    if files != [] do
-      wrapper fn -> Enum.map files, &Code.require_file(&1) end
-    else
-      {:error, "-r : No files matched pattern #{pattern}"}
-    end
-  end
-
-  defp process_command({:parallel_require, pattern}, _config) when is_binary(pattern) do
-    files = filter_patterns(pattern)
-
-    if files != [] do
-      wrapper fn -> Kernel.ParallelRequire.files(files) end
-    else
-      {:error, "-pr : No files matched pattern #{pattern}"}
-    end
-  end
-
-  defp process_command({:compile, patterns}, config) do
-    # If ensuring the dir returns an error no files will be found.
-    _ = :filelib.ensure_dir(:filename.join(config.output, "."))
-
-    case filter_multiple_patterns(patterns) do
-      {:ok, []} ->
-        {:error, "No files matched provided patterns"}
-      {: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)
-        end
-      {:missing, missing} ->
-        {:error, "No files matched pattern(s) #{Enum.join(missing, ",")}"}
-    end
-  end
-
-  defp filter_patterns(pattern) do
-    pattern
-    |> Path.wildcard
-    |> :lists.usort
-    |> Enum.filter(&File.regular?/1)
-  end
-
-  defp filter_multiple_patterns(patterns) do
-    {files, missing} =
-      Enum.reduce patterns, {[], []}, fn pattern, {files, missing} ->
-        case filter_patterns(pattern) do
-          [] -> {files, [pattern | missing]}
-          match -> {match ++ files, missing}
-        end
-      end
-
-    case missing do
-      [] -> {:ok, :lists.usort(files)}
-      _  -> {:missing, :lists.usort(missing)}
-    end
-  end
-
-  defp wrapper(fun) do
-    _ = fun.()
-    :ok
-  end
-
-  defp find_elixir_executable(file) do
-    if exec = System.find_executable(file) do
-      # If we are on Windows, the executable is going to be
-      # a .bat file that must be in the same directory as
-      # the actual Elixir executable.
-      case :os.type() do
-        {:win32, _} ->
-          base = Path.rootname(exec)
-          if File.regular?(base), do: base, else: exec
-        _ ->
-          exec
-      end
-    end
-  end
-end

lib/elixir/lib/kernel/error_handler.ex

@@ -1,42 +0,0 @@
-# Implement error_handler pattern for Erlang
-# which is integrated with Kernel.ParallelCompiler
-defmodule Kernel.ErrorHandler do
-  @moduledoc false
-
-  @spec undefined_function(module, atom, list) :: term
-  def undefined_function(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module)
-    :error_handler.undefined_function(module, fun, args)
-  end
-
-  @spec undefined_lambda(module, fun, list) :: term
-  def undefined_lambda(module, fun, args) do
-    ensure_loaded(module) or ensure_compiled(module, :module)
-    :error_handler.undefined_lambda(module, fun, args)
-  end
-
-  @spec ensure_loaded(module) :: boolean
-  def ensure_loaded(module) do
-    case :code.ensure_loaded(module) do
-      {:module, _} -> true
-      {:error, _} -> false
-    end
-  end
-
-  @spec ensure_compiled(module, atom) :: boolean
-  # Never wait on nil because it should never be defined.
-  def ensure_compiled(nil, _kind) do
-    false
-  end
-
-  def ensure_compiled(module, kind) do
-    parent = :erlang.get(:elixir_compiler_pid)
-    ref    = :erlang.make_ref
-    send parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()}
-    :erlang.garbage_collect(self())
-    receive do
-      {^ref, :found}     -> true
-      {^ref, :not_found} -> false
-    end
-  end
-end

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -1,266 +0,0 @@
-# This is an Elixir module responsible for tracking references
-# to modules, remote dispatches, and the usage of
-# aliases/imports/requires in the Elixir scope.
-#
-# Note that since this is required for bootstrap, we can't use
-# any of the `GenServer.Behaviour` conveniences.
-defmodule Kernel.LexicalTracker do
-  @moduledoc false
-  @timeout 30_000
-  @behaviour :gen_server
-
-  @doc """
-  Returns all remotes referenced in this lexical scope.
-  """
-  def remote_references(arg) do
-    :gen_server.call(to_pid(arg), :remote_references, @timeout)
-  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
-
-  @doc """
-  Gets the destination the lexical scope is meant to
-  compile to.
-  """
-  def dest(arg) do
-    :gen_server.call(to_pid(arg), :dest, @timeout)
-  end
-
-  defp to_pid(pid) when is_pid(pid),  do: pid
-  defp to_pid(mod) when is_atom(mod) do
-    table = :elixir_module.data_table(mod)
-    [{_, val}] = :ets.lookup(table, {:elixir, :lexical_tracker})
-    val
-  end
-
-  # Internal API
-
-  # Starts the tracker and returns its PID.
-  @doc false
-  def start_link(dest) do
-    :gen_server.start_link(__MODULE__, dest, [])
-  end
-
-  @doc false
-  def stop(pid) do
-    :gen_server.cast(pid, :stop)
-  end
-
-  @doc false
-  def add_import(pid, module, fas, line, warn) when is_atom(module) do
-    :gen_server.cast(pid, {:add_import, module, fas, line, warn})
-  end
-
-  @doc false
-  def add_alias(pid, module, line, warn) when is_atom(module) do
-    :gen_server.cast(pid, {:add_alias, module, line, warn})
-  end
-
-  @doc false
-  def remote_reference(pid, module, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_reference, module, mode})
-  end
-
-  @doc false
-  def remote_dispatch(pid, module, fa, line, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:remote_dispatch, module, fa, line, mode})
-  end
-
-  @doc false
-  def import_dispatch(pid, module, fa, line, mode) when is_atom(module) do
-    :gen_server.cast(pid, {:import_dispatch, module, fa, line, mode})
-  end
-
-  @doc false
-  def alias_dispatch(pid, module) when is_atom(module) do
-    :gen_server.cast(pid, {:alias_dispatch, module})
-  end
-
-  @doc false
-  def write_cache(pid, value) do
-    key = :erlang.unique_integer()
-    :gen_server.cast(pid, {:write_cache, key, value})
-    key
-  end
-
-  @doc false
-  def read_cache(pid, key) do
-    :gen_server.call(pid, {:read_cache, key}, @timeout)
-  end
-
-  @doc false
-  def collect_unused_imports(pid) do
-    unused(pid, :import)
-  end
-
-  @doc false
-  def collect_unused_aliases(pid) do
-    unused(pid, :alias)
-  end
-
-  defp unused(pid, tag) do
-    :gen_server.call(pid, {:unused, tag}, @timeout)
-  end
-
-  # Callbacks
-
-  def init(dest) do
-    {:ok, %{directives: %{}, references: %{}, compile: %{},
-            runtime: %{}, dest: dest, cache: %{}}}
-  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}
-  end
-
-  def handle_call(:remote_references, _from, state) do
-    {:reply, partition(Enum.to_list(state.references), [], []), state}
-  end
-
-  def handle_call(:remote_dispatches, _from, state) do
-    {:reply, {state.compile, state.runtime}, state}
-  end
-
-  def handle_call(:dest, _from, state) do
-    {:reply, state.dest, state}
-  end
-
-  def handle_call({:read_cache, key}, _from, %{cache: cache} = state) do
-    {:reply, Map.fetch!(cache, key), state}
-  end
-
-  def handle_cast({:write_cache, key, value}, %{cache: cache} = state) do
-    {:noreply, Map.put(state, :cache, Map.put(cache, key, value))}
-  end
-
-  def handle_cast({:remote_reference, module, mode}, state) do
-    {:noreply, %{state | references: add_reference(state.references, module, mode)}}
-  end
-
-  def handle_cast({:remote_dispatch, module, fa, line, mode}, state) do
-    references = add_reference(state.references, module, mode)
-    state = add_remote_dispatch(state, module, fa, line, mode)
-    {:noreply, %{state | references: references}}
-  end
-
-  def handle_cast({:import_dispatch, module, {function, arity} = fa, line, mode}, state) do
-    state =
-      state
-      |> add_import_dispatch(module, function, arity)
-      |> add_remote_dispatch(module, fa, line, mode)
-
-    {:noreply, state}
-  end
-
-  def handle_cast({:alias_dispatch, module}, state) do
-    {:noreply, %{state | directives: add_dispatch(state.directives, module, :alias)}}
-  end
-
-  def handle_cast({:add_import, module, fas, line, warn}, state) do
-    directives =
-      state.directives
-      |> Enum.reject(&match?({{:import, {^module, _, _}}, _}, &1))
-      |> :maps.from_list
-      |> add_directive(module, line, warn, :import)
-
-    directives =
-      Enum.reduce(fas, directives, fn {function, arity}, directives ->
-        add_directive(directives, {module, function, arity}, line, warn, :import)
-      end)
-
-    {:noreply, %{state | directives: directives}}
-  end
-
-  def handle_cast({:add_alias, module, line, warn}, state) do
-    {:noreply, %{state | directives: add_directive(state.directives, module, line, warn, :alias)}}
-  end
-
-  def handle_cast(:stop, state) do
-    {:stop, :normal, state}
-  end
-
-  @doc false
-  def handle_info(_msg, state) do
-    {:noreply, state}
-  end
-
-  @doc false
-  def terminate(_reason, _state) do
-    :ok
-  end
-
-  @doc false
-  def code_change(_old, state, _extra) 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.
-  # 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
-    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
-  end
-end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -1,348 +0,0 @@
-defmodule Kernel.ParallelCompiler do
-  @moduledoc """
-  A module responsible for compiling files in parallel.
-  """
-
-  @doc """
-  Compiles the given files.
-
-  Those files are compiled in parallel and can automatically
-  detect dependencies between them. Once a dependency is found,
-  the current file stops being compiled until the dependency is
-  resolved.
-
-  If there is an error during compilation or if `warnings_as_errors`
-  is set to `true` and there is a warning, this function will fail
-  with an exception.
-
-  This function accepts the following options:
-
-    * `:each_file` - for each file compiled, invokes the callback passing the
-      file
-
-    * `:each_long_compilation` - for each file that takes more than a given
-      timeout (see the `:long_compilation_threshold` option) to compile, invoke
-      this callback passing the file as its argument
-
-    * `:long_compilation_threshold` - the timeout (in seconds) after the
-      `:each_long_compilation` callback is invoked; defaults to `10`
-
-    * `:each_module` - for each module compiled, invokes the callback passing
-      the file, module and the module bytecode
-
-    * `:each_warning` - for each warning, invokes the callback passing
-      the file, line number, and warning message
-
-    * `:dest` - the destination directory for the BEAM files. When using `files/2`,
-      this information is only used to properly annotate the BEAM files before
-      they are loaded into memory. If you want a file to actually be written to
-      `dest`, use `files_to_path/3` instead.
-
-  Returns the modules generated by each compiled file.
-  """
-  def files(files, options \\ [])
-
-  def files(files, options) when is_list(options) do
-    spawn_compilers(files, nil, options)
-  end
-
-  @doc """
-  Compiles the given files to the given path.
-  Read `files/2` for more information.
-  """
-  def files_to_path(files, path, options \\ [])
-
-  def files_to_path(files, path, options) when is_binary(path) and is_list(options) do
-    spawn_compilers(files, path, options)
-  end
-
-  defp spawn_compilers(files, path, options) do
-    true = Code.ensure_loaded?(Kernel.ErrorHandler)
-    compiler_pid = self()
-    :elixir_code_server.cast({:reset_warnings, compiler_pid})
-    schedulers = max(:erlang.system_info(:schedulers_online), 2)
-
-    result = spawn_compilers(%{
-      entries: files,
-      original: files,
-      output: path,
-      options: options,
-      waiting: [],
-      queued: [],
-      schedulers: schedulers,
-      result: [],
-    })
-
-    # In case --warning-as-errors is enabled and there was a warning,
-    # compilation status will be set to error.
-    case :elixir_code_server.call({:compilation_status, compiler_pid}) do
-      :ok ->
-        result
-      :error ->
-        IO.puts :stderr, "Compilation failed due to warnings while using the --warnings-as-errors option"
-        exit({:shutdown, 1})
-    end
-  end
-
-  # We already have n=schedulers currently running, don't spawn new ones
-  defp spawn_compilers(%{queued: queued, waiting: waiting, schedulers: schedulers} = state)
-      when length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(state)
-  end
-
-  # Release waiting processes
-  defp spawn_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})
-  end
-
-  defp spawn_compilers(%{entries: [file | files], queued: queued, output: output, options: options} = state) do
-    parent = self()
-
-    {pid, ref} =
-      :erlang.spawn_monitor fn ->
-        # Set the elixir_compiler_pid used by our custom Kernel.ErrorHandler.
-        :erlang.put(:elixir_compiler_pid, parent)
-        :erlang.put(:elixir_compiler_file, file)
-        :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-
-        result =
-          try do
-            _ = if output do
-              :elixir_compiler.file_to_path(file, output)
-            else
-              :elixir_compiler.file(file, Keyword.get(options, :dest))
-            end
-            :ok
-          catch
-            kind, reason ->
-              {kind, reason, System.stacktrace}
-          end
-
-        send(parent, {:file_compiled, self(), file, result})
-        exit(:shutdown)
-      end
-
-    timeout = Keyword.get(options, :long_compilation_threshold, 10) * 1_000
-    timer_ref = Process.send_after(self(), {:timed_out, pid}, timeout)
-
-    new_queued = [{pid, ref, file, timer_ref} | queued]
-    spawn_compilers(%{state | entries: files, queued: new_queued})
-  end
-
-  # No more files, nothing waiting, queue is empty, we are done
-  defp spawn_compilers(%{entries: [], waiting: [], queued: [], result: result}) do
-    for {:module, mod} <- result, do: mod
-  end
-
-  # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-  defp spawn_compilers(%{entries: [], waiting: waiting, queued: queued} = state) when length(waiting) == length(queued) do
-    entries = for {pid, _, _, _} <- queued,
-                  entry = waiting_on_without_definition(waiting, pid),
-                  {_, _, ref, on, _} = entry,
-                  do: {on, {ref, :not_found}}
-
-    # Instead of releasing all files at once, we release them in groups
-    # based on the module they are waiting on. We pick the module being
-    # depended on with less edges, as it is the mostly likely source of
-    # error (for example, someone made a typo). This may not always be
-    # true though: for example, if there is a macro injecting code into
-    # multiple modules and such code becomes faulty, now multiple modules
-    # are waiting on the same module required by the faulty code. However,
-    # since we need to pick something to be first, the one with fewer edges
-    # sounds like a sane choice.
-    entries
-    |> Enum.group_by(&elem(&1, 0), &elem(&1, 1))
-    |> Enum.sort_by(&length(elem(&1, 1)))
-    |> case do
-      [{_on, refs} | _] -> spawn_compilers(%{state | entries: refs})
-      [] -> handle_deadlock(waiting, queued)
-    end
-  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
-  end
-
-  # Wait for messages from child processes
-  defp wait_for_messages(state) do
-    %{entries: entries, options: options, waiting: waiting, queued: queued, result: result} = state
-
-    receive do
-      {:struct_available, module} ->
-        available = for {:struct, _, ref, waiting_module, _defining} <- waiting,
-                        module == waiting_module,
-                        do: {ref, :found}
-
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:struct, module} | result]})
-
-      {:module_available, child, ref, file, module, binary} ->
-        if callback = Keyword.get(options, :each_module) do
-          callback.(file, module, binary)
-        end
-
-        # Release the module loader which is waiting for an ack
-        send child, {ref, :ack}
-
-        available = for {:module, _, ref, waiting_module, _defining} <- waiting,
-                        module == waiting_module,
-                        do: {ref, :found}
-
-        cancel_waiting_timer(queued, child)
-
-        spawn_compilers(%{state | entries: available ++ entries, result: [{:module, module} | result]})
-
-      {:waiting, kind, child, ref, on, defining} ->
-        # Oops, we already got it, do not put it on waiting.
-        # Alternatively, we're waiting on ourselves,
-        # send :found so that we can crash with a better error.
-        waiting =
-          if :lists.any(&match?({^kind, ^on}, &1), result) or on in defining do
-            send child, {ref, :found}
-            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
-        end
-        spawn_compilers(state)
-
-      {:warning, file, line, message} ->
-        if callback = Keyword.get(options, :each_warning) do
-          callback.(file, line, message)
-        end
-        wait_for_messages(state)
-
-      {:file_compiled, child_pid, file, :ok} ->
-        discard_down(child_pid)
-
-        if callback = Keyword.get(options, :each_file) do
-          callback.(file)
-        end
-
-        cancel_waiting_timer(queued, child_pid)
-
-        # Sometimes we may have spurious entries in the waiting
-        # list because someone invoked try/rescue UndefinedFunctionError
-        new_entries = List.delete(entries, child_pid)
-        new_queued  = List.keydelete(queued, child_pid, 0)
-        new_waiting = List.keydelete(waiting, child_pid, 1)
-        spawn_compilers(%{state | entries: new_entries, waiting: new_waiting, queued: new_queued})
-
-      {:file_compiled, child_pid, file, {kind, reason, stack}} ->
-        discard_down(child_pid)
-        print_error(file, kind, reason, stack)
-        terminate(queued)
-
-      {:DOWN, ref, :process, _pid, reason} ->
-        handle_down(queued, ref, reason)
-        wait_for_messages(state)
-    end
-  end
-
-  defp discard_down(pid) do
-    receive do
-      {:DOWN, _, :process, ^pid, _} -> :ok
-    end
-  end
-
-  defp handle_down(_queued, _ref, :normal) do
-    :ok
-  end
-  defp handle_down(queued, ref, reason) do
-    case List.keyfind(queued, ref, 1) do
-      {_child, ^ref, file, _timer_ref} ->
-        print_error(file, :exit, reason, [])
-        terminate(queued)
-      _ ->
-        :ok
-    end
-  end
-
-  defp handle_deadlock(waiting, queued) do
-    deadlock =
-      for {pid, _, file, _} <- queued do
-        {:current_stacktrace, stacktrace} = Process.info(pid, :current_stacktrace)
-        Process.exit(pid, :kill)
-
-        {_kind, ^pid, _, on, _} = List.keyfind(waiting, pid, 1)
-        error = CompileError.exception(description: "deadlocked waiting on module #{inspect on}",
-                                       file: nil, line: nil)
-        print_error(file, :error, error, stacktrace)
-
-        {file, on}
-      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 terminate(queued) do
-    for {pid, _, _, _} <- queued do
-      Process.exit(pid, :kill)
-    end
-    exit({:shutdown, 1})
-  end
-
-  defp print_error(file, kind, reason, stack) do
-    IO.write ["\n== Compilation error in file #{Path.relative_to_cwd(file)} ==\n",
-             Kernel.CLI.format_error(kind, reason, stack)]
-  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
-        end
-      nil ->
-        :ok
-    end
-  end
-end

lib/elixir/lib/kernel/parallel_require.ex

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

lib/elixir/lib/kernel/utils.ex

@@ -1,125 +0,0 @@
-import Kernel, except: [destructure: 2, defdelegate: 2, defstruct: 2]
-
-defmodule Kernel.Utils do
-  @moduledoc false
-
-  @doc """
-  Callback for destructure.
-  """
-  def destructure(list, count) when is_list(list) and is_integer(count) and count >= 0,
-    do: destructure_list(list, count)
-  def destructure(nil, count) when is_integer(count) and count >= 0,
-    do: destructure_nil(count)
-
-  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_nil(0), do: []
-  defp destructure_nil(count), do: [nil | destructure_nil(count - 1)]
-
-  @doc """
-  Callback for defdelegate.
-  """
-  def defdelegate(fun, opts) when is_list(opts) do
-    # TODO: Remove by 2.0
-    append_first? = Keyword.get(opts, :append_first, false)
-
-    {name, args} =
-      case Macro.decompose_call(fun) do
-        {_, _} = pair -> pair
-        _ -> raise ArgumentError, "invalid syntax in defdelegate #{Macro.to_string(fun)}"
-      end
-
-    as = Keyword.get(opts, :as, name)
-    as_args = build_as_args(args, append_first?)
-
-    {name, args, as, as_args}
-  end
-
-  defp build_as_args(args, append_first?) do
-    as_args = :lists.map(&build_as_arg/1, args)
-
-    case append_first? do
-      true -> tl(as_args) ++ [hd(as_args)]
-      false -> as_args
-    end
-  end
-
-  defp build_as_arg({:\\, _, [arg, _default_arg]}), do: validate_arg(arg)
-  defp build_as_arg(arg), do: validate_arg(arg)
-
-  defp validate_arg({name, _, mod} = arg) when is_atom(name) and is_atom(mod) do
-    arg
-  end
-
-  defp validate_arg(ast) do
-    raise ArgumentError, "defdelegate/2 only accepts function parameters, got: #{Macro.to_string(ast)}"
-  end
-
-  @doc """
-  Callback for defstruct.
-  """
-  def defstruct(module, fields) do
-    case fields do
-      fs when is_list(fs) ->
-        :ok
-      other ->
-        raise ArgumentError, "struct fields definition must be list, got: #{inspect other}"
-    end
-
-    fields = :lists.map(fn
-      {key, val} when is_atom(key) ->
-        try do
-          Macro.escape(val)
-        rescue
-          e in [ArgumentError] ->
-            raise ArgumentError, "invalid value for struct field #{key}, " <> Exception.message(e)
-        else
-          _ -> {key, val}
-        end
-      key when is_atom(key) ->
-        {key, nil}
-      other ->
-        raise ArgumentError, "struct field names must be atoms, got: #{inspect other}"
-    end, fields)
-
-    enforce_keys = List.wrap(Module.get_attribute(module, :enforce_keys))
-
-    :lists.foreach(fn
-      key when is_atom(key) -> :ok
-      key -> raise ArgumentError, "keys given to @enforce_keys must be atoms, got: #{inspect key}"
-    end, enforce_keys)
-
-    {:maps.put(:__struct__, module, :maps.from_list(fields)),
-     enforce_keys,
-     Module.get_attribute(module, :derive)}
-  end
-
-  @doc """
-  Announcing callback for defstruct.
-  """
-  def announce_struct(module) do
-    case :erlang.get(:elixir_compiler_pid) do
-      :undefined -> :ok
-      pid -> send(pid, {:struct_available, module})
-    end
-  end
-
-  @doc """
-  Callback for raise.
-  """
-  def raise(msg) when is_binary(msg) do
-    RuntimeError.exception(msg)
-  end
-  def raise(atom) when is_atom(atom) do
-    atom.exception([])
-  end
-  def raise(%{__struct__: struct, __exception__: true} = exception) when is_atom(struct) do
-    exception
-  end
-  def raise(other) do
-    ArgumentError.exception("raise/1 expects a module name, string or exception as " <>
-                            "the first argument, got: #{inspect other}")
-  end
-end

lib/elixir/lib/keyword.ex

@@ -1,986 +0,0 @@
-defmodule Keyword do
-  @moduledoc """
-  A set of functions for working with keywords.
-
-  A keyword is a list of two-element tuples where the first
-  element of the tuple is an atom and the second element
-  can be any value.
-
-  For example, the following is a keyword list:
-
-      [{:exit_on_close, true}, {:active, :once}, {:packet_size, 1024}]
-
-  Elixir provides a special and more concise syntax for keyword lists
-  that looks like this:
-
-      [exit_on_close: true, active: :once, packet_size: 1024]
-
-  This is also the syntax that Elixir uses to inspect keyword lists:
-
-      iex> [{:active, :once}]
-      [active: :once]
-
-  The two syntaxes are completely equivalent. Note that when keyword
-  lists are passed as the last argument to a function, if the short-hand
-  syntax is used then the square brackets around the keyword list can
-  be omitted as well. For example, the following:
-
-      String.split("1-0", "-", trim: true, parts: 2)
-
-  is equivalent to:
-
-      String.split("1-0", "-", [trim: true, parts: 2])
-
-  A keyword may have duplicated keys so it is not strictly
-  a key-value store. However most of the functions in this module
-  behave exactly as a dictionary so they work similarly to
-  the functions you would find in the `Map` module.
-
-  For example, `Keyword.get/3` will get the first entry matching
-  the given key, regardless if duplicated entries exist.
-  Similarly, `Keyword.put/3` and `Keyword.delete/3` ensure all
-  duplicated entries for a given key are removed when invoked.
-  Note that operations that require keys to be found in the keyword
-  list (like `Keyword.get/3`) need to traverse the list in order
-  to find keys, so these operations may be slower than their map
-  counterparts.
-
-  A handful of functions exist to handle duplicated keys, in
-  particular, `Enum.into/2` allows creating new keywords without
-  removing duplicated keys, `get_values/2` returns all values for
-  a given key and `delete_first/2` deletes just one of the existing
-  entries.
-
-  The functions in `Keyword` do not guarantee any property when
-  it comes to ordering. However, since a keyword list is simply a
-  list, all the operations defined in `Enum` and `List` can be
-  applied too, especially when ordering is required.
-  """
-
-  @compile :inline_list_funcs
-
-  @type key :: atom
-  @type value :: any
-
-  @type t :: [{key, value}]
-  @type t(value) :: [{key, value}]
-
-  @doc """
-  Returns `true` if `term` is a keyword list; otherwise returns `false`.
-
-  ## Examples
-
-      iex> Keyword.keyword?([])
-      true
-      iex> Keyword.keyword?([a: 1])
-      true
-      iex> Keyword.keyword?([{Foo, 1}])
-      true
-      iex> Keyword.keyword?([{}])
-      false
-      iex> Keyword.keyword?([:key])
-      false
-      iex> Keyword.keyword?(%{})
-      false
-
-  """
-  @spec keyword?(term) :: boolean
-  def keyword?(term)
-
-  def keyword?([{key, _value} | rest]) when is_atom(key), do: keyword?(rest)
-  def keyword?([]),     do: true
-  def keyword?(_other), do: false
-
-  @doc """
-  Returns an empty keyword list, i.e. an empty list.
-
-  ## Examples
-
-      iex> Keyword.new()
-      []
-
-  """
-  @spec new :: []
-  def new, do: []
-
-  @doc """
-  Creates a keyword from an enumerable.
-
-  Duplicated entries are removed, the latest one prevails.
-  Unlike `Enum.into(enumerable, [])`, `Keyword.new(enumerable)`
-  guarantees the keys are unique.
-
-  ## Examples
-
-      iex> Keyword.new([{:b, 1}, {:a, 2}])
-      [b: 1, a: 2]
-
-      iex> Keyword.new([{:a, 1}, {:a, 2}, {:a, 3}])
-      [a: 3]
-
-  """
-  @spec new(Enum.t) :: t
-  def new(pairs) do
-    new(pairs, fn pair -> pair end)
-  end
-
-  @doc """
-  Creates a keyword from an enumerable via the transformation function.
-
-  Duplicated entries are removed, the latest one prevails.
-  Unlike `Enum.into(enumerable, [], fun)`,
-  `Keyword.new(enumerable, fun)` guarantees the keys are unique.
-
-  ## Examples
-
-      iex> Keyword.new([:a, :b], fn(x) -> {x, x} end)
-      [a: :a, b: :b]
-
-  """
-  @spec new(Enum.t, (term -> {key, value})) :: t
-  def new(pairs, transform) do
-    fun = fn el, acc ->
-      {k, v} = transform.(el)
-      put_new(acc, k, v)
-    end
-    :lists.foldl(fun, [], Enum.reverse(pairs))
-  end
-
-  @doc """
-  Gets the value for a specific `key`.
-
-  If `key` does not exist, return the default value
-  (`nil` if no default value).
-
-  If duplicated entries exist, the first one is returned.
-  Use `get_values/2` to retrieve all entries.
-
-  ## Examples
-
-      iex> Keyword.get([], :a)
-      nil
-      iex> Keyword.get([a: 1], :a)
-      1
-      iex> Keyword.get([a: 1], :b)
-      nil
-      iex> Keyword.get([a: 1], :b, 3)
-      3
-
-  With duplicated keys:
-
-      iex> Keyword.get([a: 1, a: 2], :a, 3)
-      1
-      iex> Keyword.get([a: 1, a: 2], :b, 3)
-      3
-
-  """
-  @spec get(t, key, value) :: value
-  def get(keywords, key, default \\ nil) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, value} -> value
-      false -> default
-    end
-  end
-
-  @doc """
-  Gets the value for a specific `key`.
-
-  If `key` does not exist, lazily evaluates `fun` and returns its result.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  If duplicated entries exist, the first one is returned.
-  Use `get_values/2` to retrieve all entries.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Keyword.get_lazy(keyword, :a, fun)
-      1
-      iex> Keyword.get_lazy(keyword, :b, fun)
-      13
-
-  """
-  @spec get_lazy(t, key, (() -> value)) :: value
-  def get_lazy(keywords, key, fun)
-      when is_list(keywords) and is_atom(key) and is_function(fun, 0) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, value} -> value
-      false -> fun.()
-    end
-  end
-
-  @doc """
-  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.
-
-  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
-
-      iex> Keyword.get_and_update([a: 1], :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, [a: "new value!"]}
-
-      iex> Keyword.get_and_update([a: 1], :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> 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
-  def get_and_update(keywords, key, fun)
-    when is_list(keywords) and is_atom(key),
-    do: get_and_update(keywords, [], key, fun)
-
-  defp get_and_update([{key, current} | t], acc, key, fun) do
-    case fun.(current) do
-      {get, value} ->
-        {get, :lists.reverse(acc, [{key, value} | t])}
-      :pop ->
-        {current, :lists.reverse(acc, t)}
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
-    end
-  end
-
-  defp get_and_update([{_, _} = h | t], acc, key, fun),
-    do: get_and_update(t, [h | acc], key, fun)
-
-  defp get_and_update([], acc, key, fun) do
-    case fun.(nil) do
-      {get, update} ->
-        {get, [{key, update} | :lists.reverse(acc)]}
-      :pop ->
-        {nil, :lists.reverse(acc)}
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
-    end
-  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
-  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`.
-
-  ## Examples
-
-      iex> Keyword.get_and_update!([a: 1], :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, [a: "new value!"]}
-
-      iex> Keyword.get_and_update!([a: 1], :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      ** (KeyError) key :b not found in: [a: 1]
-
-      iex> Keyword.get_and_update!([a: 1], :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, []}
-
-  """
-  @spec get_and_update!(t, key, (value -> {get, value})) :: {get, t} | no_return when get: term
-  def get_and_update!(keywords, key, fun) do
-    get_and_update!(keywords, key, fun, [])
-  end
-
-  defp get_and_update!([{key, value} | keywords], key, fun, acc) do
-    case fun.(value) do
-      {get, value} ->
-        {get, :lists.reverse(acc, [{key, value} | delete(keywords, key)])}
-      :pop ->
-        {value, :lists.reverse(acc, keywords)}
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
-    end
-  end
-
-  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
-    raise(KeyError, key: key, term: acc)
-  end
-
-  @doc """
-  Fetches the value for a specific `key` and returns it in a tuple.
-
-  If the `key` does not exist, returns `:error`.
-
-  ## Examples
-
-      iex> Keyword.fetch([a: 1], :a)
-      {:ok, 1}
-      iex> Keyword.fetch([a: 1], :b)
-      :error
-
-  """
-  @spec fetch(t, key) :: {:ok, value} | :error
-  def fetch(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, value} -> {:ok, value}
-      false -> :error
-    end
-  end
-
-  @doc """
-  Fetches the value for specific `key`.
-
-  If `key` does not exist, a `KeyError` is raised.
-
-  ## Examples
-
-      iex> Keyword.fetch!([a: 1], :a)
-      1
-      iex> Keyword.fetch!([a: 1], :b)
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @spec fetch!(t, key) :: value | no_return
-  def fetch!(keywords, key) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, value} -> value
-      false -> raise(KeyError, key: key, term: keywords)
-    end
-  end
-
-  @doc """
-  Gets all values for a specific `key`.
-
-  ## Examples
-
-      iex> Keyword.get_values([], :a)
-      []
-      iex> Keyword.get_values([a: 1], :a)
-      [1]
-      iex> Keyword.get_values([a: 1, a: 2], :a)
-      [1, 2]
-
-  """
-  @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}
-      {_, _} -> false
-    end
-    :lists.filtermap(fun, keywords)
-  end
-
-  @doc """
-  Returns all keys from the keyword list.
-
-  Duplicated keys appear duplicated in the final list of keys.
-
-  ## Examples
-
-      iex> Keyword.keys([a: 1, b: 2])
-      [:a, :b]
-      iex> Keyword.keys([a: 1, b: 2, a: 3])
-      [:a, :b, :a]
-
-  """
-  @spec keys(t) :: [key]
-  def keys(keywords) when is_list(keywords) do
-    :lists.map(fn {k, _} -> k end, keywords)
-  end
-
-  @doc """
-  Returns all values from the keyword list.
-
-  Values from duplicated keys will be kept in the final list of values.
-
-  ## Examples
-
-      iex> Keyword.values([a: 1, b: 2])
-      [1, 2]
-      iex> Keyword.values([a: 1, b: 2, a: 3])
-      [1, 2, 3]
-
-  """
-  @spec values(t) :: [value]
-  def values(keywords) when is_list(keywords) do
-    :lists.map(fn {_, v} -> v end, keywords)
-  end
-
-  @doc """
-  Deletes the entries in the keyword list for a `key` with `value`.
-
-  If no `key` with `value` exists, returns the keyword list unchanged.
-
-  ## Examples
-
-      iex> Keyword.delete([a: 1, b: 2], :a, 1)
-      [b: 2]
-      iex> Keyword.delete([a: 1, b: 2, a: 3], :a, 3)
-      [a: 1, b: 2]
-      iex> Keyword.delete([a: 1], :a, 5)
-      [a: 1]
-      iex> Keyword.delete([a: 1], :b, 5)
-      [a: 1]
-
-  """
-  @spec delete(t, key, value) :: t
-  def delete(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    :lists.filter(fn {k, v} -> k != key or v != value end, keywords)
-  end
-
-  @doc """
-  Deletes the entries in the keyword list for a specific `key`.
-
-  If the `key` does not exist, returns the keyword list unchanged.
-  Use `delete_first/2` to delete just the first entry in case of
-  duplicated keys.
-
-  ## Examples
-
-      iex> Keyword.delete([a: 1, b: 2], :a)
-      [b: 2]
-      iex> Keyword.delete([a: 1, b: 2, a: 3], :a)
-      [b: 2]
-      iex> Keyword.delete([b: 2], :a)
-      [b: 2]
-
-  """
-  @spec delete(t, key) :: t
-  def delete(keywords, key) when is_list(keywords) and is_atom(key) do
-    :lists.filter(fn {k, _} -> k != key end, keywords)
-  end
-
-  @doc """
-  Deletes the first entry in the keyword list for a specific `key`.
-
-  If the `key` does not exist, returns the keyword list unchanged.
-
-  ## Examples
-
-      iex> Keyword.delete_first([a: 1, b: 2, a: 3], :a)
-      [b: 2, a: 3]
-      iex> Keyword.delete_first([b: 2], :a)
-      [b: 2]
-
-  """
-  @spec delete_first(t, key) :: t
-  def delete_first(keywords, key) when is_list(keywords) and is_atom(key) do
-    :lists.keydelete(key, 1, keywords)
-  end
-
-  @doc """
-  Puts the given `value` under `key`.
-
-  If a previous value is already stored, all entries are
-  removed and the value is overridden.
-
-  ## Examples
-
-      iex> Keyword.put([a: 1], :b, 2)
-      [b: 2, a: 1]
-      iex> Keyword.put([a: 1, b: 2], :a, 3)
-      [a: 3, b: 2]
-      iex> Keyword.put([a: 1, b: 2, a: 4], :a, 3)
-      [a: 3, b: 2]
-
-  """
-  @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)]
-  end
-
-  @doc """
-  Evaluates `fun` and puts the result under `key`
-  in keyword list unless `key` is already present.
-
-  This is useful if the value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   3
-      ...> end
-      iex> Keyword.put_new_lazy(keyword, :a, fun)
-      [a: 1]
-      iex> Keyword.put_new_lazy(keyword, :b, fun)
-      [b: 3, a: 1]
-
-  """
-  @spec put_new_lazy(t, key, (() -> value)) :: t
-  def put_new_lazy(keywords, key, fun)
-      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]
-    end
-  end
-
-  @doc """
-  Puts the given `value` under `key` unless the entry `key`
-  already exists.
-
-  ## Examples
-
-      iex> Keyword.put_new([a: 1], :b, 2)
-      [b: 2, a: 1]
-      iex> Keyword.put_new([a: 1, b: 2], :a, 3)
-      [a: 1, b: 2]
-
-  """
-  @spec put_new(t, key, value) :: t
-  def put_new(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> keywords
-      false -> [{key, value} | keywords]
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in the keyword list.
-
-  In the case a value is stored multiple times in the keyword list,
-  later occurrences are removed.
-
-  ## Examples
-
-      iex> Keyword.replace([a: 1], :b, 2)
-      [a: 1]
-      iex> Keyword.replace([a: 1, b: 2, a: 4], :a, 3)
-      [a: 3, b: 2]
-
-  """
-  @spec replace(t, key, value) :: t
-  def replace(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> [{key, value} | delete(keywords, key)]
-      false -> keywords
-    end
-  end
-
-  @doc """
-  Similar to `replace/3`, but will raise a `KeyError`
-  if the entry `key` does not exist.
-
-  ## Examples
-
-      iex> Keyword.replace!([a: 1, b: 2, a: 4], :a, 3)
-      [a: 3, b: 2]
-      iex> Keyword.replace!([a: 1], :b, 2)
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @spec replace!(t, key, value) :: t
-  def replace!(keywords, key, value) when is_list(keywords) and is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      {^key, _} -> [{key, value} | delete(keywords, key)]
-      false -> raise KeyError, key: key, term: keywords
-    end
-  end
-
-  @doc """
-  Checks if two keywords are equal.
-
-  Two keywords are considered to be equal if they contain
-  the same keys and those keys contain the same values.
-
-  ## Examples
-
-      iex> Keyword.equal?([a: 1, b: 2], [b: 2, a: 1])
-      true
-      iex> Keyword.equal?([a: 1, b: 2], [b: 1, a: 2])
-      false
-      iex> Keyword.equal?([a: 1, b: 2, a: 3], [b: 2, a: 3, a: 1])
-      true
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(left, right) when is_list(left) and is_list(right) do
-    :lists.sort(left) == :lists.sort(right)
-  end
-
-  @doc """
-  Merges two keyword lists into one.
-
-  All keys, including duplicated keys, given in `keywords2` will be added
-  to `keywords1`, overriding any existing one.
-
-  There are no guarantees about the order of keys in the returned keyword.
-
-  ## Examples
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4])
-      [b: 2, a: 3, d: 4]
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5])
-      [b: 2, a: 3, d: 4, a: 5]
-
-      iex> Keyword.merge([a: 1], [2, 3])
-      ** (ArgumentError) expected a keyword list as the second argument, got: [2, 3]
-
-  """
-  @spec merge(t, t) :: t
-  def merge(keywords1, keywords2) when is_list(keywords1) and is_list(keywords2) do
-    if keyword?(keywords2) do
-      fun = fn
-        {key, _value} when is_atom(key) ->
-          not has_key?(keywords2, key)
-        _ ->
-          raise ArgumentError, message: "expected a keyword list as the first argument, got: #{inspect keywords1}"
-      end
-      :lists.filter(fun, keywords1) ++ keywords2
-    else
-      raise ArgumentError, message: "expected a keyword list as the second argument, got: #{inspect keywords2}"
-    end
-  end
-
-  @doc """
-  Merges two keyword lists into one.
-
-  All keys, including duplicated keys, given in `keywords2` will be added
-  to `keywords1`. The given function will be invoked to solve conflicts.
-
-  If `keywords2` has duplicate keys, the given function will be invoked
-  for each matching pair in `keywords1`.
-
-  There are no guarantees about the order of keys in the returned keyword.
-
-  ## Examples
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn _k, v1, v2 ->
-      ...>   v1 + v2
-      ...> end)
-      [b: 2, a: 4, d: 4]
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
-      ...>  v1 + v2
-      ...> end)
-      [b: 2, a: 4, d: 4, a: 5]
-
-      iex> Keyword.merge([a: 1, b: 2, a: 3], [a: 3, d: 4, a: 5], fn :a, v1, v2 ->
-      ...>  v1 + v2
-      ...> end)
-      [b: 2, a: 4, d: 4, a: 8]
-
-      iex> Keyword.merge([a: 1, b: 2], [:a, :b], fn :a, v1, v2 ->
-      ...>  v1 + v2
-      ...> end)
-      ** (ArgumentError) expected a keyword list as the second argument, got: [:a, :b]
-
-  """
-  @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(keywords1, keywords2, fun) when is_list(keywords1) and is_list(keywords2) and is_function(fun, 3) do
-    if keyword?(keywords1) do
-      do_merge(keywords2, [], keywords1, keywords1, fun, keywords2)
-    else
-      raise ArgumentError, message: "expected a keyword list as the first argument, got: #{inspect keywords1}"
-    end
-  end
-
-  defp do_merge([{key, value2} | tail], acc, rest, original, fun, keywords2) when is_atom(key) do
-    case :lists.keyfind(key, 1, original) do
-      {^key, value1} ->
-        do_merge(tail, [{key, fun.(key, value1, value2)} | acc],
-                 delete(rest, key), :lists.keydelete(key, 1, original), fun, keywords2)
-
-      false ->
-        do_merge(tail, [{key, value2} | acc], rest, original, fun, keywords2)
-    end
-  end
-
-  defp do_merge([], acc, rest, _original, _fun, _keywords2) do
-    rest ++ :lists.reverse(acc)
-  end
-
-  defp do_merge(_other, _acc, _rest, _original, _fun, keywords2) do
-    raise ArgumentError, message: "expected a keyword list as the second argument, got: #{inspect keywords2}"
-  end
-
-  @doc """
-  Returns whether a given `key` exists in the given `keywords`.
-
-  ## Examples
-
-      iex> Keyword.has_key?([a: 1], :a)
-      true
-      iex> Keyword.has_key?([a: 1], :b)
-      false
-
-  """
-  @spec has_key?(t, key) :: boolean
-  def has_key?(keywords, key) when is_list(keywords) and is_atom(key) do
-    :lists.keymember(key, 1, keywords)
-  end
-
-  @doc """
-  Updates the `key` with the given function.
-
-  If the `key` does not exist, raises `KeyError`.
-
-  If there are duplicated keys, they are all removed and only the first one
-  is updated.
-
-  ## Examples
-
-      iex> Keyword.update!([a: 1], :a, &(&1 * 2))
-      [a: 2]
-      iex> Keyword.update!([a: 1, a: 2], :a, &(&1 * 2))
-      [a: 2]
-
-      iex> Keyword.update!([a: 1], :b, &(&1 * 2))
-      ** (KeyError) key :b not found in: [a: 1]
-
-  """
-  @spec update!(t, key, (value -> value)) :: t | no_return
-  def update!(keywords, key, fun) do
-    update!(keywords, key, fun, keywords)
-  end
-
-  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)]
-  end
-
-  defp update!([], key, _fun, dict) when is_atom(key) do
-    raise(KeyError, key: key, term: dict)
-  end
-
-  @doc """
-  Updates the `key` in `keywords` with the given function.
-
-  If the `key` does not exist, inserts the given `initial` value.
-
-  If there are duplicated keys, they are all removed and only the first one
-  is updated.
-
-  ## Examples
-
-      iex> Keyword.update([a: 1], :a, 13, &(&1 * 2))
-      [a: 2]
-      iex> Keyword.update([a: 1, a: 2], :a, 13, &(&1 * 2))
-      [a: 2]
-      iex> Keyword.update([a: 1], :b, 11, &(&1 * 2))
-      [a: 1, b: 11]
-
-  """
-  @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)]
-  end
-
-  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
-    [{key, initial}]
-  end
-
-  @doc """
-  Takes all entries corresponding to the given keys and extracts them into a
-  separate keyword list.
-
-  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.
-
-  Entries with duplicated keys end up in the same keyword list.
-
-  ## Examples
-
-      iex> Keyword.split([a: 1, b: 2, c: 3], [:a, :c, :e])
-      {[a: 1, c: 3], [b: 2]}
-      iex> Keyword.split([a: 1, b: 2, c: 3, a: 4], [:a, :c, :e])
-      {[a: 1, c: 3, a: 4], [b: 2]}
-
-  """
-  @spec split(t, [key]) :: {t, t}
-  def split(keywords, keys) when is_list(keywords) do
-    fun = fn {k, v}, {take, drop} ->
-      case k in keys do
-        true  -> {[{k, v} | take], drop}
-        false -> {take, [{k, v} | drop]}
-      end
-    end
-
-    acc = {[], []}
-    {take, drop} = :lists.foldl(fun, acc, keywords)
-    {:lists.reverse(take), :lists.reverse(drop)}
-  end
-
-  @doc """
-  Takes all entries corresponding to the given keys and returns them in a new
-  keyword list.
-
-  Duplicated keys are preserved in the new keyword list.
-
-  ## Examples
-
-      iex> Keyword.take([a: 1, b: 2, c: 3], [:a, :c, :e])
-      [a: 1, c: 3]
-      iex> Keyword.take([a: 1, b: 2, c: 3, a: 5], [:a, :c, :e])
-      [a: 1, c: 3, a: 5]
-
-  """
-  @spec take(t, [key]) :: t
-  def take(keywords, keys) when is_list(keywords) do
-    :lists.filter(fn {k, _} -> k in keys end, keywords)
-  end
-
-  @doc """
-  Drops the given keys from the keyword list.
-
-  Duplicated keys are preserved in the new keyword list.
-
-  ## Examples
-
-      iex> Keyword.drop([a: 1, b: 2, c: 3], [:b, :d])
-      [a: 1, c: 3]
-      iex> Keyword.drop([a: 1, b: 2, b: 3, c: 3, a: 5], [:b, :d])
-      [a: 1, c: 3, a: 5]
-
-  """
-  @spec drop(t, [key]) :: t
-  def drop(keywords, keys) when is_list(keywords) do
-    :lists.filter(fn {key, _} -> key not in keys end, keywords)
-  end
-
-  @doc """
-  Returns and removes all values associated with `key` in the keyword list.
-
-  All duplicated keys are removed. See `pop_first/3` for
-  removing only the first entry.
-
-  ## Examples
-
-      iex> Keyword.pop([a: 1], :a)
-      {1, []}
-      iex> Keyword.pop([a: 1], :b)
-      {nil, [a: 1]}
-      iex> Keyword.pop([a: 1], :b, 3)
-      {3, [a: 1]}
-      iex> Keyword.pop([a: 1, a: 2], :a)
-      {1, []}
-
-  """
-  @spec pop(t, key, value) :: {value, t}
-  def pop(keywords, key, default \\ nil) when is_list(keywords) do
-    case fetch(keywords, key) do
-      {:ok, value} ->
-        {value, delete(keywords, key)}
-      :error ->
-        {default, keywords}
-    end
-  end
-
-  @doc """
-  Lazily returns and removes all values associated with `key` in the keyword list.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  All duplicated keys are removed. See `pop_first/3` for
-  removing only the first entry.
-
-  ## Examples
-
-      iex> keyword = [a: 1]
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Keyword.pop_lazy(keyword, :a, fun)
-      {1, []}
-      iex> Keyword.pop_lazy(keyword, :b, fun)
-      {13, [a: 1]}
-
-  """
-  @spec pop_lazy(t, key, (() -> value)) :: {value, t}
-  def pop_lazy(keywords, key, fun)
-      when is_list(keywords) and is_function(fun, 0) do
-    case fetch(keywords, key) do
-      {:ok, value} ->
-        {value, delete(keywords, key)}
-      :error ->
-        {fun.(), keywords}
-    end
-  end
-
-  @doc """
-  Returns and removes the first value associated with `key` in the keyword list.
-
-  Duplicated keys are not removed.
-
-  ## Examples
-
-      iex> Keyword.pop_first([a: 1], :a)
-      {1, []}
-      iex> Keyword.pop_first([a: 1], :b)
-      {nil, [a: 1]}
-      iex> Keyword.pop_first([a: 1], :b, 3)
-      {3, [a: 1]}
-      iex> Keyword.pop_first([a: 1, a: 2], :a)
-      {1, [a: 2]}
-
-  """
-  @spec pop_first(t, key, value) :: {value, t}
-  def pop_first(keywords, key, default \\ nil) when is_list(keywords) do
-    case :lists.keytake(key, 1, keywords) do
-      {:value, {^key, value}, rest} -> {value, rest}
-      false -> {default, keywords}
-    end
-  end
-
-  @doc """
-  Returns the keyword list itself.
-
-  ## Examples
-
-      iex> Keyword.to_list([a: 1])
-      [a: 1]
-
-  """
-  @spec to_list(t) :: t
-  def to_list(keyword) when is_list(keyword) do
-    keyword
-  end
-
-  @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def size(keyword) do
-    length(keyword)
-  end
-end

lib/elixir/lib/list.ex

@@ -1,965 +0,0 @@
-defmodule List do
-  @moduledoc """
-  Functions that work on (linked) lists.
-
-  Lists in Elixir are specified between square brackets:
-
-      iex> [1, "two", 3, :four]
-      [1, "two", 3, :four]
-
-  Two lists can be concatenated and subtracted using the
-  `Kernel.++/2` and `Kernel.--/2` operators:
-
-      iex> [1, 2, 3] ++ [4, 5, 6]
-      [1, 2, 3, 4, 5, 6]
-      iex> [1, true, 2, false, 3, true] -- [true, false]
-      [1, 2, 3, true]
-
-  Lists in Elixir are effectively linked lists, which means
-  they are internally represented in pairs containing the
-  head and the tail of a list:
-
-      iex> [head | tail] = [1, 2, 3]
-      iex> head
-      1
-      iex> tail
-      [2, 3]
-
-  Similarly, we could write the list `[1, 2, 3]` using only
-  such pairs (called cons cells):
-
-      iex> [1 | [2 | [3 | []]]]
-      [1, 2, 3]
-
-  Some lists, called improper lists, do not have an empty list as
-  the second element in the last cons cell:
-
-      iex> [1 | [2 | [3 | 4]]]
-      [1, 2, 3 | 4]
-
-  Although improper lists are generally avoided, they are used in some
-  special circumstances like iodata and chardata entities (see the `IO` module).
-
-  Due to their cons cell based representation, prepending an element
-  to a list is always fast (constant time), while appending becomes
-  slower as the list grows in size (linear time):
-
-      iex> list = [1, 2, 3]
-      iex> [0 | list]   # fast
-      [0, 1, 2, 3]
-      iex> list ++ [4]  # slow
-      [1, 2, 3, 4]
-
-  The `Kernel` module contains many functions to manipulate lists
-  and that are allowed in guards. For example, `Kernel.hd/1` to
-  retrieve the head, `Kernel.tl/1` to fetch the tail and
-  `Kernel.length/1` for calculating the length. Keep in mind that,
-  similar to appending to a list, calculating the length needs to
-  traverse the whole list.
-
-  ## Charlists
-
-  If a list is made of non-negative integers, it can also be called
-  a charlist. Elixir uses single quotes to define charlists:
-
-      iex> 'héllo'
-      [104, 233, 108, 108, 111]
-
-  In particular, charlists 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
-  instead of Elixir strings. One example of such functions
-  is `Application.loaded_applications/0`:
-
-      Application.loaded_applications
-      #=>  [{:stdlib, 'ERTS  CXC 138 10', '2.6'},
-            {:compiler, 'ERTS  CXC 138 10', '6.0.1'},
-            {:elixir, 'elixir', '1.0.0'},
-            {:kernel, 'ERTS  CXC 138 10', '4.1'},
-            {:logger, 'logger', '1.0.0'}]
-
-  ## List and Enum modules
-
-  This module aims to provide operations that are specific
-  to lists, like conversion between data types, updates,
-  deletions and key lookups (for lists of tuples). For traversing
-  lists in general, developers should use the functions in the
-  `Enum` module that work across a variety of data types.
-
-  In both `Enum` and `List` modules, any kind of index access
-  on a list is linear. Negative indexes are also supported but
-  they imply the list will be iterated twice, one to calculate
-  the proper index and another to perform the operation.
-  """
-
-  @compile :inline_list_funcs
-
-  @doc """
-  Deletes the given `item` from the `list`. Returns a new list without
-  the item.
-
-  If the `item` occurs more than once in the `list`, just
-  the first occurrence is removed.
-
-  ## Examples
-
-      iex> List.delete([:a, :b, :c], :a)
-      [:b, :c]
-
-      iex> List.delete([:a, :b, :b, :c], :b)
-      [:a, :b, :c]
-
-  """
-  @spec delete(list, any) :: list
-  def delete(list, item)
-  def delete([item | list], item), do: list
-  def delete([other | list], item), do: [other | delete(list, item)]
-  def delete([], _item), do: []
-
-  @doc """
-  Duplicates the given element `n` times in a list.
-
-  ## Examples
-
-      iex> List.duplicate("hello", 3)
-      ["hello", "hello", "hello"]
-
-      iex> List.duplicate([1, 2], 2)
-      [[1, 2], [1, 2]]
-
-  """
-  @spec duplicate(elem, non_neg_integer) :: [elem] when elem: var
-  def duplicate(elem, n) do
-    :lists.duplicate(n, elem)
-  end
-
-  @doc """
-  Flattens the given `list` of nested lists.
-
-  ## Examples
-
-      iex> List.flatten([1, [[2], 3]])
-      [1, 2, 3]
-
-  """
-  @spec flatten(deep_list) :: list when deep_list: [any | deep_list]
-  def flatten(list) do
-    :lists.flatten(list)
-  end
-
-  @doc """
-  Flattens the given `list` of nested lists.
-  The list `tail` will be added at the end of
-  the flattened list.
-
-  ## Examples
-
-      iex> List.flatten([1, [[2], 3]], [4, 5])
-      [1, 2, 3, 4, 5]
-
-  """
-  @spec flatten(deep_list, [elem]) :: [elem] when elem: var, deep_list: [elem | deep_list]
-  def flatten(list, tail) do
-    :lists.flatten(list, tail)
-  end
-
-  @doc """
-  Folds (reduces) the given list from the left with
-  a function. Requires an accumulator.
-
-  ## Examples
-
-      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)
-      2
-
-  """
-  @spec foldl([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldl(list, acc, function) when is_list(list) and is_function(function) do
-    :lists.foldl(function, acc, list)
-  end
-
-  @doc """
-  Folds (reduces) the given list from the right with
-  a function. Requires an accumulator.
-
-  ## Examples
-
-      iex> List.foldr([1, 2, 3, 4], 0, fn(x, acc) -> x - acc end)
-      -2
-
-  """
-  @spec foldr([elem], acc, (elem, acc -> acc)) :: acc when elem: var, acc: var
-  def foldr(list, acc, function) when is_list(list) and is_function(function) do
-    :lists.foldr(function, acc, list)
-  end
-
-  @doc """
-  Returns the first element in `list` or `nil` if `list` is empty.
-
-  ## Examples
-
-      iex> List.first([])
-      nil
-
-      iex> List.first([1])
-      1
-
-      iex> List.first([1, 2, 3])
-      1
-
-  """
-  @spec first([elem]) :: nil | elem when elem: var
-  def first([]),      do: nil
-  def first([head | _]), do: head
-
-  @doc """
-  Returns the last element in `list` or `nil` if `list` is empty.
-
-  ## Examples
-
-      iex> List.last([])
-      nil
-
-      iex> List.last([1])
-      1
-
-      iex> List.last([1, 2, 3])
-      3
-
-  """
-  @spec last([elem]) :: nil | elem when elem: var
-  def last([]), do: nil
-  def last([head]), do: head
-  def last([_ | tail]), do: last(tail)
-
-  @doc """
-  Receives a list of tuples and returns the first tuple
-  where the item at `position` in the tuple matches the
-  given `key`.
-
-  ## Examples
-
-      iex> List.keyfind([a: 1, b: 2], :a, 0)
-      {:a, 1}
-
-      iex> List.keyfind([a: 1, b: 2], 2, 1)
-      {:b, 2}
-
-      iex> List.keyfind([a: 1, b: 2], :c, 0)
-      nil
-
-  """
-  @spec keyfind([tuple], any, non_neg_integer, any) :: any
-  def keyfind(list, key, position, default \\ nil) do
-    :lists.keyfind(key, position + 1, list) || default
-  end
-
-  @doc """
-  Receives a list of tuples and returns `true` if there is
-  a tuple where the item at `position` in the tuple matches
-  the given `key`.
-
-  ## Examples
-
-      iex> List.keymember?([a: 1, b: 2], :a, 0)
-      true
-
-      iex> List.keymember?([a: 1, b: 2], 2, 1)
-      true
-
-      iex> List.keymember?([a: 1, b: 2], :c, 0)
-      false
-
-  """
-  @spec keymember?([tuple], any, non_neg_integer) :: boolean
-  def keymember?(list, key, position) do
-    :lists.keymember(key, position + 1, list)
-  end
-
-  @doc """
-  Receives a list of tuples and replaces the item
-  identified by `key` at `position` if it exists.
-
-  ## Examples
-
-      iex> List.keyreplace([a: 1, b: 2], :a, 0, {:a, 3})
-      [a: 3, b: 2]
-
-  """
-  @spec keyreplace([tuple], any, non_neg_integer, tuple) :: [tuple]
-  def keyreplace(list, key, position, new_tuple) do
-    :lists.keyreplace(key, position + 1, list, new_tuple)
-  end
-
-  @doc """
-  Receives a list of tuples and sorts the items
-  at `position` of the tuples. The sort is stable.
-
-  ## Examples
-
-      iex> List.keysort([a: 5, b: 1, c: 3], 1)
-      [b: 1, c: 3, a: 5]
-
-      iex> List.keysort([a: 5, c: 1, b: 3], 0)
-      [a: 5, b: 3, c: 1]
-
-  """
-  @spec keysort([tuple], non_neg_integer) :: [tuple]
-  def keysort(list, position) do
-    :lists.keysort(position + 1, list)
-  end
-
-  @doc """
-  Receives a `list` of tuples and replaces the item
-  identified by `key` at `position`.
-
-  If the item does not exist, it is added to the end of the `list`.
-
-  ## Examples
-
-      iex> List.keystore([a: 1, b: 2], :a, 0, {:a, 3})
-      [a: 3, b: 2]
-
-      iex> List.keystore([a: 1, b: 2], :c, 0, {:c, 3})
-      [a: 1, b: 2, c: 3]
-
-  """
-  @spec keystore([tuple], any, non_neg_integer, tuple) :: [tuple, ...]
-  def keystore(list, key, position, new_tuple) do
-    :lists.keystore(key, position + 1, list, new_tuple)
-  end
-
-  @doc """
-  Receives a `list` of tuples and deletes the first tuple
-  where the item at `position` matches the
-  given `key`. Returns the new list.
-
-  ## Examples
-
-      iex> List.keydelete([a: 1, b: 2], :a, 0)
-      [b: 2]
-
-      iex> List.keydelete([a: 1, b: 2], 2, 1)
-      [a: 1]
-
-      iex> List.keydelete([a: 1, b: 2], :c, 0)
-      [a: 1, b: 2]
-
-  """
-  @spec keydelete([tuple], any, non_neg_integer) :: [tuple]
-  def keydelete(list, key, position) do
-    :lists.keydelete(key, position + 1, list)
-  end
-
-  @doc """
-  Receives a `list` of tuples and returns the first tuple
-  where the element at `position` in the tuple matches the
-  given `key`, as well as the `list` without found tuple.
-
-  If such a tuple is not found, `nil` will be returned.
-
-  ## Examples
-
-      iex> List.keytake([a: 1, b: 2], :a, 0)
-      {{:a, 1}, [b: 2]}
-
-      iex> List.keytake([a: 1, b: 2], 2, 1)
-      {{:b, 2}, [a: 1]}
-
-      iex> List.keytake([a: 1, b: 2], :c, 0)
-      nil
-
-  """
-  @spec keytake([tuple], any, non_neg_integer) :: {tuple, [tuple]} | nil
-  def keytake(list, key, position) do
-    case :lists.keytake(key, position + 1, list) do
-      {:value, item, list} -> {item, list}
-      false                -> nil
-    end
-  end
-
-  @doc """
-  Wraps the argument in a list.
-
-  If the argument is already a list, returns the list.
-  If the argument is `nil`, returns an empty list.
-
-  ## Examples
-
-      iex> List.wrap("hello")
-      ["hello"]
-
-      iex> List.wrap([1, 2, 3])
-      [1, 2, 3]
-
-      iex> List.wrap(nil)
-      []
-
-  """
-  @spec wrap(list | any) :: list
-  def wrap(list) when is_list(list) do
-    list
-  end
-
-  def wrap(nil) do
-    []
-  end
-
-  def wrap(other) do
-    [other]
-  end
-
-  @doc """
-  Zips corresponding elements from each list in `list_of_lists`.
-
-  The zipping finishes as soon as any list terminates.
-
-  ## Examples
-
-      iex> List.zip([[1, 2], [3, 4], [5, 6]])
-      [{1, 3, 5}, {2, 4, 6}]
-
-      iex> List.zip([[1, 2], [3], [5, 6]])
-      [{1, 3, 5}]
-
-  """
-  @spec zip([list]) :: [tuple]
-  def zip([]), do: []
-  def zip(list_of_lists) when is_list(list_of_lists) do
-    do_zip(list_of_lists, [])
-  end
-
-  @doc """
-  Returns a list with `value` inserted at the specified `index`.
-
-  Note that `index` is capped at the list length. Negative indices
-  indicate an offset from the end of the `list`.
-
-  ## Examples
-
-      iex> List.insert_at([1, 2, 3, 4], 2, 0)
-      [1, 2, 0, 3, 4]
-
-      iex> List.insert_at([1, 2, 3], 10, 0)
-      [1, 2, 3, 0]
-
-      iex> List.insert_at([1, 2, 3], -1, 0)
-      [1, 2, 3, 0]
-
-      iex> List.insert_at([1, 2, 3], -10, 0)
-      [0, 1, 2, 3]
-
-  """
-  @spec insert_at(list, integer, any) :: list
-  def insert_at(list, index, value) when is_integer(index) do
-    if index < 0 do
-      do_insert_at(list, length(list) + index + 1, value)
-    else
-      do_insert_at(list, index, value)
-    end
-  end
-
-  @doc """
-  Returns a list with a replaced value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
-  If `index` is out of bounds, the original `list` is returned.
-
-  ## Examples
-
-      iex> List.replace_at([1, 2, 3], 0, 0)
-      [0, 2, 3]
-
-      iex> List.replace_at([1, 2, 3], 10, 0)
-      [1, 2, 3]
-
-      iex> List.replace_at([1, 2, 3], -1, 0)
-      [1, 2, 0]
-
-      iex> List.replace_at([1, 2, 3], -10, 0)
-      [1, 2, 3]
-
-  """
-  @spec replace_at(list, integer, any) :: list
-  def replace_at(list, index, value) when is_integer(index) do
-    if index < 0 do
-      do_replace_at(list, length(list) + index, value)
-    else
-      do_replace_at(list, index, value)
-    end
-  end
-
-  @doc """
-  Returns a list with an updated value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
-  If `index` is out of bounds, the original `list` is returned.
-
-  ## Examples
-
-      iex> List.update_at([1, 2, 3], 0, &(&1 + 10))
-      [11, 2, 3]
-
-      iex> List.update_at([1, 2, 3], 10, &(&1 + 10))
-      [1, 2, 3]
-
-      iex> List.update_at([1, 2, 3], -1, &(&1 + 10))
-      [1, 2, 13]
-
-      iex> List.update_at([1, 2, 3], -10, &(&1 + 10))
-      [1, 2, 3]
-
-  """
-  @spec update_at([elem], integer, (elem -> any)) :: list when elem: var
-  def update_at(list, index, fun) when is_function(fun, 1) and is_integer(index) do
-    if index < 0 do
-      do_update_at(list, length(list) + index, fun)
-    else
-      do_update_at(list, index, fun)
-    end
-  end
-
-  @doc """
-  Produces a new list by removing the value at the specified `index`.
-
-  Negative indices indicate an offset from the end of the `list`.
-  If `index` is out of bounds, the original `list` is returned.
-
-  ## Examples
-
-      iex> List.delete_at([1, 2, 3], 0)
-      [2, 3]
-
-      iex> List.delete_at([1, 2, 3], 10)
-      [1, 2, 3]
-
-      iex> List.delete_at([1, 2, 3], -1)
-      [1, 2]
-
-  """
-  @spec delete_at(list, integer) :: list
-  def delete_at(list, index) when is_integer(index) do
-    elem(pop_at(list, index), 1)
-  end
-
-  @doc """
-  Returns and removes the value at the specified `index` in the `list`.
-
-  Negative indices indicate an offset from the end of the `list`.
-  If `index` is out of bounds, the original `list` is returned.
-
-  ## Examples
-
-      iex> List.pop_at([1, 2, 3], 0)
-      {1, [2, 3]}
-      iex> List.pop_at([1, 2, 3], 5)
-      {nil, [1, 2, 3]}
-      iex> List.pop_at([1, 2, 3], 5, 10)
-      {10, [1, 2, 3]}
-      iex> List.pop_at([1, 2, 3], -1)
-      {3, [1, 2]}
-
-  """
-  @spec pop_at(list, integer, any) :: {any, list}
-  def pop_at(list, index, default \\ nil) when is_integer(index) do
-    if index < 0 do
-      do_pop_at(list, length(list) + index, default, [])
-    else
-      do_pop_at(list, index, default, [])
-    end
-  end
-
-  @doc """
-  Returns `true` if `list` starts with the given `prefix` list; otherwise returns `false`.
-
-  If `prefix` is an empty list, it returns `true`.
-
-  ### Examples
-
-      iex> List.starts_with?([1, 2, 3], [1, 2])
-      true
-
-      iex> List.starts_with?([1, 2], [1, 2, 3])
-      false
-
-      iex> List.starts_with?([:alpha], [])
-      true
-
-      iex> List.starts_with?([], [:alpha])
-      false
-
-  """
-  @spec starts_with?(list, list) :: boolean
-  @spec starts_with?(list, []) :: true
-  @spec starts_with?([], nonempty_list) :: false
-  def starts_with?(list, prefix)
-
-  def starts_with?([head | tail], [head | prefix_tail]),
-    do: starts_with?(tail, prefix_tail);
-  def starts_with?(list, []) when is_list(list),
-    do: true
-  def starts_with?(list, [_ | _]) when is_list(list),
-    do: false
-
-  @doc """
-  Converts a charlist to an atom.
-
-  Currently Elixir does not support conversions from charlists
-  which contains Unicode codepoints greater than 0xFF.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> List.to_atom('elixir')
-      :elixir
-
-  """
-  @spec to_atom(charlist) :: atom
-  def to_atom(charlist) do
-    :erlang.list_to_atom(charlist)
-  end
-
-  @doc """
-  Converts a charlist to an existing atom. Raises an `ArgumentError`
-  if the atom does not exist.
-
-  Currently Elixir does not support conversions from charlists
-  which contains Unicode codepoints greater than 0xFF.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> _ = :my_atom
-      iex> List.to_existing_atom('my_atom')
-      :my_atom
-
-      iex> List.to_existing_atom('this_atom_will_never_exist')
-      ** (ArgumentError) argument error
-
-  """
-  @spec to_existing_atom(charlist) :: atom
-  def to_existing_atom(charlist) do
-    :erlang.list_to_existing_atom(charlist)
-  end
-
-  @doc """
-  Returns the float whose text representation is `charlist`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> List.to_float('2.2017764e+0')
-      2.2017764
-
-  """
-  @spec to_float(charlist) :: float
-  def to_float(charlist) do
-    :erlang.list_to_float(charlist)
-  end
-
-  @doc """
-  Returns an integer whose text representation is `charlist`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> List.to_integer('123')
-      123
-
-  """
-  @spec to_integer(charlist) :: integer
-  def to_integer(charlist) do
-    :erlang.list_to_integer(charlist)
-  end
-
-  @doc """
-  Returns an integer whose text representation is `charlist` in base `base`.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> List.to_integer('3FF', 16)
-      1023
-
-  """
-  @spec to_integer(charlist, 2..36) :: integer
-  def to_integer(charlist, base) do
-    :erlang.list_to_integer(charlist, base)
-  end
-
-  @doc """
-  Converts a list to a tuple.
-
-  Inlined by the compiler.
-
-  ## Examples
-
-      iex> List.to_tuple([:share, [:elixir, 163]])
-      {:share, [:elixir, 163]}
-
-  """
-  @spec to_tuple(list) :: tuple
-  def to_tuple(list) do
-    :erlang.list_to_tuple(list)
-  end
-
-  @doc """
-  Converts a list of integers representing codepoints, lists or
-  strings into a string.
-
-  Notice that this function expects a list of integers representing
-  UTF-8 codepoints. If you have a list of bytes, you must instead use
-  the [`:binary` module](http://www.erlang.org/doc/man/binary.html).
-
-  ## Examples
-
-      iex> List.to_string([0x00E6, 0x00DF])
-      "æß"
-
-      iex> List.to_string([0x0061, "bc"])
-      "abc"
-
-  """
-  @spec to_string(:unicode.charlist) :: String.t
-  def to_string(list) when is_list(list) do
-    try do
-      :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}
-        """
-    else
-      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 """
-  Returns a keyword list that represents an *edit script*.
-
-  The algorithm is outlined in the
-  "An O(ND) Difference Algorithm and Its Variations" paper by E. Myers.
-
-  An *edit script* is a keyword list. Each key describes the "editing action" to
-  take in order to bring `list1` closer to being equal to `list2`; a key can be
-  `:eq`, `:ins`, or `:del`. Each value is a sublist of either `list1` or `list2`
-  that should be inserted (if the corresponding key `:ins`), deleted (if the
-  corresponding key is `:del`), or left alone (if the corresponding key is
-  `:eq`) in `list1` in order to be closer to `list2`.
-
-  ## Examples
-
-      iex> List.myers_difference([1, 4, 2, 3], [1, 2, 3, 4])
-      [eq: [1], del: [4], eq: [2, 3], ins: [4]]
-
-  """
-  @spec myers_difference(list, list) :: [{:eq | :ins | :del, list}] | nil
-  def myers_difference(list1, list2) when is_list(list1) and is_list(list2) do
-    path = {0, 0, list1, list2, []}
-    find_script(0, length(list1) + length(list2), [path])
-  end
-
-  defp find_script(envelope, max, _paths) when envelope > max do
-    nil
-  end
-
-  defp find_script(envelope, max, paths) do
-    case each_diagonal(-envelope, envelope, paths, []) do
-      {:done, edits} -> compact_reverse(edits, [])
-      {:next, paths} -> find_script(envelope + 1, max, paths)
-    end
-  end
-
-  defp compact_reverse([], acc), do: acc
-
-  defp compact_reverse([{kind, elem} | rest], [{kind, result} | acc]) do
-    compact_reverse(rest, [{kind, [elem | result]} | acc])
-  end
-
-  defp compact_reverse([{kind, elem} | rest], acc) do
-    compact_reverse(rest, [{kind, [elem]} | acc])
-  end
-
-  defp each_diagonal(diag, limit, _paths, next_paths) when diag > limit do
-    {:next, Enum.reverse(next_paths)}
-  end
-
-  defp each_diagonal(diag, limit, paths, next_paths) do
-    {path, rest} = proceed_path(diag, limit, paths)
-    with {:cont, path} <- follow_snake(path) do
-      each_diagonal(diag + 2, limit, rest, [path | next_paths])
-    end
-  end
-
-  defp proceed_path(0, 0, [path]), do: {path, []}
-
-  defp proceed_path(diag, limit, [path | _] = paths) when diag == -limit do
-    {move_down(path), paths}
-  end
-
-  defp proceed_path(diag, limit, [path]) when diag == limit do
-    {move_right(path), []}
-  end
-
-  defp proceed_path(_diag, _limit, [path1, path2 | rest]) do
-    if elem(path1, 1) > elem(path2, 1) do
-      {move_right(path1), [path2 | rest]}
-    else
-      {move_down(path2), [path2 | rest]}
-    end
-  end
-
-  defp move_right({x, y, list1, [elem | rest], edits}) do
-    {x + 1, y, list1, rest, [{:ins, elem} | edits]}
-  end
-
-  defp move_right({x, y, list1, [], edits}) do
-    {x + 1, y, list1, [], edits}
-  end
-
-  defp move_down({x, y, [elem | rest], list2, edits}) do
-    {x, y + 1, rest, list2, [{:del, elem} | edits]}
-  end
-
-  defp move_down({x, y, [], list2, edits}) do
-    {x, y + 1, [], list2, edits}
-  end
-
-  defp follow_snake({x, y, [elem | rest1], [elem | rest2], edits}) do
-    follow_snake({x + 1, y + 1, rest1, rest2, [{:eq, elem} | edits]})
-  end
-
-  defp follow_snake({_x, _y, [], [], edits}) do
-    {:done, edits}
-  end
-
-  defp follow_snake(path) do
-    {:cont, path}
-  end
-
-  ## Helpers
-
-  # replace_at
-
-  defp do_replace_at([], _index, _value) do
-    []
-  end
-
-  defp do_replace_at(list, index, _value) when index < 0 do
-    list
-  end
-
-  defp do_replace_at([_old | rest], 0, value) do
-    [value | rest]
-  end
-
-  defp do_replace_at([head | tail], index, value) do
-    [head | do_replace_at(tail, index - 1, value)]
-  end
-
-  # insert_at
-
-  defp do_insert_at([], _index, value) do
-    [value]
-  end
-
-  defp do_insert_at(list, index, value) when index <= 0 do
-    [value | list]
-  end
-
-  defp do_insert_at([head | tail], index, value) do
-    [head | do_insert_at(tail, index - 1, value)]
-  end
-
-  # update_at
-
-  defp do_update_at([value | list], 0, fun) do
-    [fun.(value) | list]
-  end
-
-  defp do_update_at(list, index, _fun) when index < 0 do
-    list
-  end
-
-  defp do_update_at([head | tail], index, fun) do
-    [head | do_update_at(tail, index - 1, fun)]
-  end
-
-  defp do_update_at([], _index, _fun) do
-    []
-  end
-
-  # pop_at
-
-  defp do_pop_at([], _index, default, acc) do
-    {default, :lists.reverse(acc)}
-  end
-
-  defp do_pop_at(list, index, default, []) when index < 0 do
-    {default, list}
-  end
-
-  defp do_pop_at([head | tail], 0, _default, acc) do
-    {head, :lists.reverse(acc, tail)}
-  end
-
-  defp do_pop_at([head | tail], index, default, acc) do
-    do_pop_at(tail, index - 1, default, [head | acc])
-  end
-
-  # zip
-
-  defp do_zip(list, acc) do
-    converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-    case :lists.mapfoldl(converter, [], list) do
-      {_, nil} -> :lists.reverse(acc)
-      {mlist, heads} ->
-        do_zip(mlist, [to_tuple(:lists.reverse(heads)) | acc])
-    end
-  end
-
-  defp do_zip_each(_, nil) do
-    {nil, nil}
-  end
-
-  defp do_zip_each([head | tail], acc) do
-    {tail, [head | acc]}
-  end
-
-  defp do_zip_each([], _) do
-    {nil, nil}
-  end
-
-  defp to_list(tuple) when is_tuple(tuple), do: Tuple.to_list(tuple)
-  defp to_list(list)  when is_list(list),   do: list
-end

lib/elixir/lib/list/chars.ex

@@ -1,62 +0,0 @@
-defprotocol List.Chars do
-  @moduledoc ~S"""
-  The `List.Chars` protocol is responsible for
-  converting a structure to a charlist (only if applicable).
-
-  The only function required to be implemented is
-  `to_charlist/1` which does the conversion.
-
-  The `to_charlist/1` function automatically imported
-  by `Kernel` invokes this protocol.
-  """
-
-  @doc """
-  Converts `term` to a charlist.
-  """
-  @spec to_charlist(t) :: charlist
-  def to_charlist(term)
-
-  @doc false
-  # TODO: Remove by 2.0
-  # (hard-deprecated in elixir_dispatch)
-  Kernel.def to_char_list(term) do
-    __MODULE__.to_charlist(term)
-  end
-end
-
-defimpl List.Chars, for: Atom do
-  def to_charlist(atom), do: Atom.to_charlist(atom)
-end
-
-defimpl List.Chars, for: BitString do
-  @doc """
-  Returns the given binary `term` converted to a charlist.
-  """
-  def to_charlist(term) when is_binary(term) do
-    String.to_charlist(term)
-  end
-
-  def to_charlist(term) do
-    raise Protocol.UndefinedError,
-             protocol: @protocol,
-                value: term,
-          description: "cannot convert a bitstring to a charlist"
-  end
-end
-
-defimpl List.Chars, for: List do
-  # Note that same inlining is used for the rewrite rule.
-  def to_charlist(list), do: list
-end
-
-defimpl List.Chars, for: Integer do
-  def to_charlist(term) do
-    Integer.to_charlist(term)
-  end
-end
-
-defimpl List.Chars, for: Float do
-  def to_charlist(term) do
-    :io_lib_format.fwrite_g(term)
-  end
-end

lib/elixir/lib/macro/env.ex

@@ -1,160 +0,0 @@
-defmodule Macro.Env do
-  @moduledoc """
-  A struct that holds compile time environment information.
-
-  The current environment can be accessed at any time as
-  `__ENV__/0`. Inside macros, the caller environment can be
-  accessed as `__CALLER__/0`.
-
-  An instance of `Macro.Env` must not be modified by hand. If you need to
-  create a custom environment to pass to `Code.eval_quoted/3`, use the
-  following trick:
-
-      def make_custom_env do
-        import SomeModule, only: [some_function: 2]
-        alias A.B.C
-        __ENV__
-      end
-
-  You may then call `make_custom_env()` to get a struct with the desired
-  imports and aliases included.
-
-  It contains the following fields:
-
-    * `module` - the current module name
-    * `file` - the current file name as a binary
-    * `line` - the current line as an integer
-    * `function` - a tuple as `{atom, integer}`, where the first
-      element is the function name and the second its arity; returns
-      `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
-    * `requires` - the list of required modules
-    * `functions` - a list of functions imported from each module
-    * `macros` - a list of macros imported from each module
-    * `macro_aliases` - a list of aliases defined inside the current macro
-    * `context_modules` - a list of modules defined in the current context
-    * `lexical_tracker` - PID of the lexical tracker which is responsible for
-      keeping user info
-    * `vars` - a list keeping all defined variables as `{var, context}`
-
-  The following fields are private and must not be accessed or relied on:
-
-    * `export_vars` - a list keeping all variables to be exported in a
-      construct (may be `nil`)
-    * `match_vars` - controls how "new" variables are handled. Inside a
-      match it is a list with all variables in a match. Outside of a match
-      is either `:warn` or `:apply`
-    * `prematch_vars` - a list of variables defined before a match (is
-      `nil` when not inside a match)
-
-  """
-
-  @type name_arity :: {atom, arity}
-  @type file :: binary
-  @type line :: non_neg_integer
-  @type aliases :: [{module, module}]
-  @type macro_aliases :: [{module, {integer, module}}]
-  @type context :: :match | :guard | nil
-  @type requires :: [module]
-  @type functions :: [{module, [name_arity]}]
-  @type macros :: [{module, [name_arity]}]
-  @type context_modules :: [module]
-  @type vars :: [{atom, atom | non_neg_integer}]
-  @type lexical_tracker :: pid | nil
-  @type local :: atom | nil
-
-  @opaque export_vars :: vars | nil
-  @opaque match_vars :: vars | :warn | :apply
-  @opaque prematch_vars :: vars | nil
-
-  @type t :: %{__struct__: __MODULE__,
-               module: atom,
-               file: file,
-               line: line,
-               function: name_arity | nil,
-               context: context,
-               requires: requires,
-               aliases: aliases,
-               functions: functions,
-               macros: macros,
-               macro_aliases: aliases,
-               context_modules: context_modules,
-               vars: vars,
-               export_vars: export_vars,
-               match_vars: match_vars,
-               prematch_vars: prematch_vars,
-               lexical_tracker: lexical_tracker}
-
-  def __struct__ do
-    %{__struct__: __MODULE__,
-      module: nil,
-      file: "nofile",
-      line: 0,
-      function: nil,
-      context: nil,
-      requires: [],
-      aliases: [],
-      functions: [],
-      macros: [],
-      macro_aliases: [],
-      context_modules: [],
-      vars: [],
-      lexical_tracker: nil,
-      export_vars: nil,
-      match_vars: :warn,
-      prematch_vars: nil}
-  end
-
-  def __struct__(kv) do
-    Enum.reduce kv, __struct__(), fn {k, v}, acc -> :maps.update(k, v, acc) end
-  end
-
-  @doc """
-  Returns a keyword list containing the file and line
-  information as keys.
-  """
-  @spec location(t) :: keyword
-  def location(env)
-  def location(%{__struct__: Macro.Env, file: file, line: line}) do
-    [file: file, line: line]
-  end
-
-  @doc """
-  Returns whether the compilation environment is currently
-  inside a guard.
-  """
-  @spec in_guard?(t) :: boolean
-  def in_guard?(env)
-  def in_guard?(%{__struct__: Macro.Env, context: context}), do: context == :guard
-
-  @doc """
-  Returns whether the compilation environment is currently
-  inside a match clause.
-  """
-  @spec in_match?(t) :: boolean
-  def in_match?(env)
-  def in_match?(%{__struct__: Macro.Env, context: context}), do: context == :match
-
-  @doc """
-  Returns the environment stacktrace.
-  """
-  @spec stacktrace(t) :: list
-  def stacktrace(%{__struct__: Macro.Env} = env) do
-    cond do
-      is_nil(env.module) ->
-        [{:elixir_compiler, :__FILE__, 1, relative_location(env)}]
-      is_nil(env.function) ->
-        [{env.module, :__MODULE__, 0, relative_location(env)}]
-      true ->
-        {name, arity} = env.function
-        [{env.module, name, arity, relative_location(env)}]
-    end
-  end
-
-  defp relative_location(env) do
-    [file: Path.relative_to_cwd(env.file), line: env.line]
-  end
-end

lib/elixir/lib/map.ex

@@ -1,870 +0,0 @@
-defmodule Map do
-  @moduledoc """
-  A set of functions for working with maps.
-
-  Maps are the "go to" key-value data structure in Elixir. Maps can be created
-  with the `%{}` syntax, and key-value pairs can be expressed as `key => value`:
-
-      iex> %{}
-      %{}
-      iex> %{"one" => :two, 3 => "four"}
-      %{3 => "four", "one" => :two}
-
-  Key-value pairs in a map do not follow any order (that's why the printed map
-  in the example above has a different order than the map that was created).
-
-  Maps do not impose any restriction on the key type: anything can be a key in a
-  map. As a key-value structure, maps do not allow duplicated keys. Keys are
-  compared using the exact-equality operator (`===`). If colliding keys are defined
-  in a map literal, the last one prevails.
-
-  When the key in a key-value pair is an atom, the `key: value` shorthand syntax
-  can be used (as in many other special forms), provided key-value pairs are put at
-  the end:
-
-      iex> %{"hello" => "world", a: 1, b: 2}
-      %{:a => 1, :b => 2, "hello" => "world"}
-
-  Keys in maps can be accessed through some of the functions in this module
-  (such as `Map.get/3` or `Map.fetch/2`) or through the `[]` syntax provided by
-  the `Access` module:
-
-      iex> map = %{a: 1, b: 2}
-      iex> Map.fetch(map, :a)
-      {:ok, 1}
-      iex> map[:b]
-      2
-      iex> map["non_existing_key"]
-      nil
-
-  The alternative access syntax `map.key` is provided alongside `[]` when the
-  map has a `:key` key; note that while `map[key]` will return `nil` if `map`
-  doesn't contain `key`, `map.key` will raise if `map` doesn't contain
-  the key `:key`.
-
-      iex> map = %{foo: "bar", baz: "bong"}
-      iex> map.foo
-      "bar"
-      iex> map.non_existing_key
-      ** (KeyError) key :non_existing_key not found in: %{baz: "bong", foo: "bar"}
-
-  Maps can be pattern matched on; when a map is on the left-hand side of a
-  pattern match, it will match if the map on the right-hand side contains the
-  keys on the left-hand side and their values match the ones on the left-hand
-  side. This means that an empty map matches every map.
-
-      iex> %{} = %{foo: "bar"}
-      %{foo: "bar"}
-      iex> %{a: a} = %{:a => 1, "b" => 2, [:c, :e, :e] => 3}
-      iex> a
-      1
-      iex> %{:c => 3} = %{:a => 1, 2 => :b}
-      ** (MatchError) no match of right hand side value: %{2 => :b, :a => 1}
-
-  Variables can be used as map keys both when writing map literals as well as
-  when matching:
-
-      iex> n = 1
-      1
-      iex> %{n => :one}
-      %{1 => :one}
-      iex> %{^n => :one} = %{1 => :one, 2 => :two, 3 => :three}
-      %{1 => :one, 2 => :two, 3 => :three}
-
-  Maps also support a specific update syntax to update the value stored under
-  *existing* atom keys:
-
-      iex> map = %{one: 1, two: 2}
-      iex> %{map | one: "one"}
-      %{one: "one", two: 2}
-      iex> %{map | three: 3}
-      ** (KeyError) key :three not found
-
-  ## Modules to work with maps
-
-  This module aims to provide functions that perform operations specific to maps
-  (like accessing keys, updating values, and so on). For traversing maps as
-  collections, developers should use the `Enum` module that works across a
-  variety of data types.
-
-  The `Kernel` module also provides a few functions to work with maps: for
-  example, `Kernel.map_size/1` to know the number of key-value pairs in a map or
-  `Kernel.is_map/1` to know if a term is a map.
-  """
-
-  @type key :: any
-  @type value :: any
-  @compile {:inline, fetch: 2, fetch!: 2, get: 2, put: 3, delete: 2, has_key?: 2, replace!: 3}
-
-  @doc """
-  Returns all keys from `map`.
-
-  ## Examples
-
-      iex> Map.keys(%{a: 1, b: 2})
-      [:a, :b]
-
-  """
-  @spec keys(map) :: [key]
-  defdelegate keys(map), to: :maps
-
-  @doc """
-  Returns all values from `map`.
-
-  ## Examples
-
-      iex> Map.values(%{a: 1, b: 2})
-      [1, 2]
-
-  """
-  @spec values(map) :: [value]
-  defdelegate values(map), to: :maps
-
-  @doc """
-  Converts `map` to a list.
-
-  Each key-value pair in the map is converted to a two-element tuple `{key,
-  value}` in the resulting list.
-
-  ## Examples
-
-      iex> Map.to_list(%{a: 1})
-      [a: 1]
-      iex> Map.to_list(%{1 => 2})
-      [{1, 2}]
-
-  """
-  @spec to_list(map) :: [{term, term}]
-  defdelegate to_list(map), to: :maps
-
-  @doc """
-  Returns a new empty map.
-
-  ## Examples
-
-      iex> Map.new
-      %{}
-
-  """
-  @spec new :: map
-  def new, do: %{}
-
-  @doc """
-  Creates a map from an `enumerable`.
-
-  Duplicated keys are removed; the latest one prevails.
-
-  ## Examples
-
-      iex> Map.new([{:b, 1}, {:a, 2}])
-      %{a: 2, b: 1}
-      iex> Map.new([a: 1, a: 2, a: 3])
-      %{a: 3}
-
-  """
-  @spec new(Enumerable.t) :: map
-  def new(enumerable)
-  def new(list) when is_list(list), do: :maps.from_list(list)
-  def new(%{__struct__: _} = struct), do: new_from_enum(struct)
-  def new(%{} = map), do: map
-  def new(enum), do: new_from_enum(enum)
-
-  defp new_from_enum(enumerable) do
-    enumerable
-    |> Enum.to_list
-    |> :maps.from_list
-  end
-
-  @doc """
-  Creates a map from an `enumerable` via the given transformation function.
-
-  Duplicated keys are removed; the latest one prevails.
-
-  ## Examples
-
-      iex> Map.new([:a, :b], fn x -> {x, x} end)
-      %{a: :a, b: :b}
-
-  """
-  @spec new(Enumerable.t, (term -> {key, value})) :: map
-  def new(enumerable, transform) when is_function(transform, 1) do
-    enumerable
-    |> Enum.to_list
-    |> new_transform(transform, [])
-  end
-
-  defp new_transform([], _fun, acc) do
-    acc
-    |> :lists.reverse
-    |> :maps.from_list
-  end
-
-  defp new_transform([item | rest], fun, acc) do
-    new_transform(rest, fun, [fun.(item) | acc])
-  end
-
-  @doc """
-  Returns whether the given `key` exists in the given `map`.
-
-  ## Examples
-
-      iex> Map.has_key?(%{a: 1}, :a)
-      true
-      iex> Map.has_key?(%{a: 1}, :b)
-      false
-
-  Inlined by the compiler.
-  """
-  @spec has_key?(map, key) :: boolean
-  def has_key?(map, key), do: :maps.is_key(key, map)
-
-  @doc """
-  Fetches the value for a specific `key` in the given `map`.
-
-  If `map` contains the given `key` with value `value`, then `{:ok, value}` is
-  returned. If `map` doesn't contain `key`, `:error` is returned.
-
-  ## Examples
-
-      iex> Map.fetch(%{a: 1}, :a)
-      {:ok, 1}
-      iex> Map.fetch(%{a: 1}, :b)
-      :error
-
-  Inlined by the compiler.
-  """
-  @spec fetch(map, key) :: {:ok, value} | :error
-  def fetch(map, key), do: :maps.find(key, map)
-
-  @doc """
-  Fetches the value for a specific `key` in the given `map`, erroring out if
-  `map` doesn't contain `key`.
-
-  If `map` contains the given `key`, the corresponding value is returned. If
-  `map` doesn't contain `key`, a `KeyError` exception is raised.
-
-  ## Examples
-
-      iex> Map.fetch!(%{a: 1}, :a)
-      1
-      iex> Map.fetch!(%{a: 1}, :b)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @spec fetch!(map, key) :: value | no_return
-  def fetch!(map, key) do
-    :maps.get(key, map)
-  end
-
-  @doc """
-  Puts the given `value` under `key` unless the entry `key`
-  already exists in `map`.
-
-  ## Examples
-
-      iex> Map.put_new(%{a: 1}, :b, 2)
-      %{a: 1, b: 2}
-      iex> Map.put_new(%{a: 1, b: 2}, :a, 3)
-      %{a: 1, b: 2}
-
-  """
-  @spec put_new(map, key, value) :: map
-  def put_new(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        map
-      %{} ->
-        put(map, key, value)
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Alters the value stored under `key` to `value`, but only
-  if the entry `key` already exists in `map`.
-
-  ## Examples
-
-      iex> Map.replace(%{a: 1}, :b, 2)
-      %{a: 1}
-      iex> Map.replace(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-  """
-  @spec replace(map, key, value) :: map
-  def replace(map, key, value) do
-    case map do
-      %{^key => _value} ->
-        put(map, key, value)
-      %{} ->
-        map
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Similar to `replace/3`, but will raise a `KeyError`
-  if the key does not exist in the map.
-
-  ## Examples
-
-      iex> Map.replace!(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-      iex> Map.replace!(%{a: 1}, :b, 2)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  Inlined by the compiler.
-  """
-  @spec replace!(map, key, value) :: map
-  def replace!(map, key, value) do
-    :maps.update(key, value, map)
-  end
-
-  @doc """
-  Evaluates `fun` and puts the result under `key`
-  in `map` unless `key` is already present.
-
-  This function is useful in case you want to compute the value to put under
-  `key` only if `key` is not already present (e.g., the value is expensive to
-  calculate or generally difficult to setup and teardown again).
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   3
-      ...> end
-      iex> Map.put_new_lazy(map, :a, fun)
-      %{a: 1}
-      iex> Map.put_new_lazy(map, :b, fun)
-      %{a: 1, b: 3}
-
-  """
-  @spec put_new_lazy(map, key, (() -> value)) :: map
-  def put_new_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => _value} ->
-        map
-      %{} ->
-        put(map, key, fun.())
-      other ->
-        :erlang.error({:badmap, other})
-    end
-  end
-
-  @doc """
-  Returns a new map with all the key-value pairs in `map` where the key
-  is in `keys`.
-
-  If `keys` contains keys that are not in `map`, they're simply ignored.
-
-  ## Examples
-
-      iex> Map.take(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
-      %{a: 1, c: 3}
-
-  """
-  @spec take(map, Enumerable.t) :: map
-  def take(map, keys)
-
-  def take(map, keys) when is_map(map) do
-    keys
-    |> Enum.to_list
-    |> take(map, [])
-  end
-
-  def take(non_map, _keys) do
-    :erlang.error({:badmap, non_map})
-  end
-
-  defp take([], _map, acc) do
-    :maps.from_list(acc)
-  end
-
-  defp take([key | rest], map, acc) do
-    acc =
-      case map do
-        %{^key => value} -> [{key, value} | acc]
-        %{} -> acc
-      end
-
-    take(rest, map, acc)
-  end
-
-  @doc """
-  Gets the value for a specific `key` in `map`.
-
-  If `key` is present in `map` with value `value`, then `value` is
-  returned. Otherwise, `default` is returned (which is `nil` unless
-  specified otherwise).
-
-  ## Examples
-
-      iex> Map.get(%{}, :a)
-      nil
-      iex> Map.get(%{a: 1}, :a)
-      1
-      iex> Map.get(%{a: 1}, :b)
-      nil
-      iex> Map.get(%{a: 1}, :b, 3)
-      3
-
-  """
-  @spec get(map, key, value) :: value
-  def get(map, key, default \\ nil) do
-    case map do
-      %{^key => value} ->
-        value
-      %{} ->
-        default
-      other ->
-        :erlang.error({:badmap, other}, [map, key, default])
-    end
-  end
-
-  @doc """
-  Gets the value for a specific `key` in `map`.
-
-  If `key` is present in `map` with value `value`, then `value` is
-  returned. Otherwise, `fun` is evaluated and its result is returned.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.get_lazy(map, :a, fun)
-      1
-      iex> Map.get_lazy(map, :b, fun)
-      13
-
-  """
-  @spec get_lazy(map, key, (() -> value)) :: value
-  def get_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => value} ->
-        value
-      %{} ->
-        fun.()
-      other ->
-        :erlang.error({:badmap, other}, [map, key, fun])
-    end
-  end
-
-  @doc """
-  Puts the given `value` under `key` in `map`.
-
-  ## Examples
-
-      iex> Map.put(%{a: 1}, :b, 2)
-      %{a: 1, b: 2}
-      iex> Map.put(%{a: 1, b: 2}, :a, 3)
-      %{a: 3, b: 2}
-
-  Inlined by the compiler.
-  """
-  @spec put(map, key, value) :: map
-  def put(map, key, value) do
-    :maps.put(key, value, map)
-  end
-
-  @doc """
-  Deletes the entry in `map` for a specific `key`.
-
-  If the `key` does not exist, returns `map` unchanged.
-
-  ## Examples
-
-      iex> Map.delete(%{a: 1, b: 2}, :a)
-      %{b: 2}
-      iex> Map.delete(%{b: 2}, :a)
-      %{b: 2}
-
-  Inlined by the compiler.
-  """
-  @spec delete(map, key) :: map
-  def delete(map, key), do: :maps.remove(key, map)
-
-  @doc """
-  Merges two maps into one.
-
-  All keys in `map2` will be added to `map1`, overriding any existing one
-  (i.e., the keys in `map2` "have precedence" over the ones in `map1`).
-
-  If you have a struct and you would like to merge a set of keys into the
-  struct, do not use this function, as it would merge all keys on the right
-  side into the struct, even if the key is not part of the struct. Instead,
-  use `Kernel.struct/2`.
-
-  ## Examples
-
-      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4})
-      %{a: 3, b: 2, d: 4}
-
-  """
-  @spec merge(map, map) :: map
-  defdelegate merge(map1, map2), to: :maps
-
-  @doc """
-  Merges two maps into one, resolving conflicts through the given `callback`.
-
-  All keys in `map2` will be added to `map1`. The given function will be invoked
-  when there are duplicate keys; its arguments are `key` (the duplicate key),
-  `value1` (the value of `key` in `map1`), and `value2` (the value of `key` in
-  `map2`). The value returned by `callback` is used as the value under `key` in
-  the resulting map.
-
-  ## Examples
-
-      iex> Map.merge(%{a: 1, b: 2}, %{a: 3, d: 4}, fn _k, v1, v2 ->
-      ...>   v1 + v2
-      ...> end)
-      %{a: 4, b: 2, d: 4}
-
-  """
-  @spec merge(map, map, (key, value, value -> value)) :: map
-  def merge(map1, map2, callback) when is_function(callback, 3) do
-    if map_size(map1) > map_size(map2) do
-      :maps.fold fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> callback.(key, val1, val2) end)
-      end, map1, map2
-    else
-      :maps.fold fn key, val2, acc ->
-        update(acc, key, val2, fn val1 -> callback.(key, val2, val1) end)
-      end, map2, map1
-    end
-  end
-
-  @doc """
-  Updates the `key` in `map` with the given function.
-
-  If `key` is present in `map` with value `value`, `fun` is invoked with
-  argument `value` and its result is used as the new value of `key`. If `key` is
-  not present in `map`, `initial` is inserted as the value of `key`. The initial
-  value will not be passed through the update function.
-
-  ## Examples
-
-      iex> Map.update(%{a: 1}, :a, 13, &(&1 * 2))
-      %{a: 2}
-      iex> Map.update(%{a: 1}, :b, 11, &(&1 * 2))
-      %{a: 1, b: 11}
-
-  """
-  @spec update(map, key, value, (value -> value)) :: map
-  def update(map, key, initial, fun) when is_function(fun, 1) do
-    case map do
-      %{^key => value} ->
-        put(map, key, fun.(value))
-      %{} ->
-        put(map, key, initial)
-      other ->
-        :erlang.error({:badmap, other}, [map, key, initial, fun])
-    end
-  end
-
-  @doc """
-  Returns and removes the value associated with `key` in `map`.
-
-  If `key` is present in `map` with value `value`, `{value, new_map}` is
-  returned where `new_map` is the result of removing `key` from `map`. If `key`
-  is not present in `map`, `{default, map}` is returned.
-
-  ## Examples
-
-      iex> Map.pop(%{a: 1}, :a)
-      {1, %{}}
-      iex> Map.pop(%{a: 1}, :b)
-      {nil, %{a: 1}}
-      iex> Map.pop(%{a: 1}, :b, 3)
-      {3, %{a: 1}}
-
-  """
-  @spec pop(map, key, value) :: {value, map}
-  def pop(map, key, default \\ nil) do
-    case map do
-      %{^key => value} ->
-        {value, delete(map, key)}
-      %{} ->
-        {default, map}
-      other ->
-        :erlang.error({:badmap, other}, [map, key, default])
-    end
-  end
-
-  @doc """
-  Lazily returns and removes the value associated with `key` in `map`.
-
-  If `key` is present in `map` with value `value`, `{value, new_map}` is
-  returned where `new_map` is the result of removing `key` from `map`. If `key`
-  is not present in `map`, `{fun_result, map}` is returned, where `fun_result`
-  is the result of applying `fun`.
-
-  This is useful if the default value is very expensive to calculate or
-  generally difficult to setup and teardown again.
-
-  ## Examples
-
-      iex> map = %{a: 1}
-      iex> fun = fn ->
-      ...>   # some expensive operation here
-      ...>   13
-      ...> end
-      iex> Map.pop_lazy(map, :a, fun)
-      {1, %{}}
-      iex> Map.pop_lazy(map, :b, fun)
-      {13, %{a: 1}}
-
-  """
-  @spec pop_lazy(map, key, (() -> value)) :: {value, map}
-  def pop_lazy(map, key, fun) when is_function(fun, 0) do
-    case map do
-      %{^key => value} ->
-        {value, delete(map, key)}
-      %{} ->
-        {fun.(), map}
-      other ->
-        :erlang.error({:badmap, other}, [map, key, fun])
-    end
-  end
-
-  @doc """
-  Drops the given `keys` from `map`.
-
-  If `keys` contains keys that are not in `map`, they're simply ignored.
-
-  ## Examples
-
-      iex> Map.drop(%{a: 1, b: 2, c: 3}, [:b, :d])
-      %{a: 1, c: 3}
-
-  """
-  @spec drop(map, Enumerable.t) :: map
-  def drop(map, keys)
-
-  def drop(map, keys) when is_map(map) do
-    keys
-    |> Enum.to_list
-    |> drop_list(map)
-  end
-
-  def drop(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
-  end
-
-  defp drop_list([], acc), do: acc
-  defp drop_list([key | rest], acc) do
-    drop_list(rest, delete(acc, key))
-  end
-
-  @doc """
-  Takes all entries corresponding to the given `keys` in `map` 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.
-
-  ## Examples
-
-      iex> Map.split(%{a: 1, b: 2, c: 3}, [:a, :c, :e])
-      {%{a: 1, c: 3}, %{b: 2}}
-
-  """
-  @spec split(map, Enumerable.t) :: {map, map}
-  def split(map, keys)
-
-  def split(map, keys) when is_map(map) do
-    keys
-    |> Enum.to_list
-    |> split([], map)
-  end
-
-  def split(non_map, keys) do
-    :erlang.error({:badmap, non_map}, [non_map, keys])
-  end
-
-  defp split([], included, excluded) do
-    {:maps.from_list(included), excluded}
-  end
-
-  defp split([key | rest], included, excluded) do
-    case excluded do
-      %{^key => value} ->
-        split(rest, [{key, value} | included], delete(excluded, key))
-      _other ->
-        split(rest, included, excluded)
-    end
-  end
-
-  @doc """
-  Updates `key` with the given function.
-
-  If `key` is present in `map` with value `value`, `fun` is invoked with
-  argument `value` and its result is used as the new value of `key`. If `key` is
-  not present in `map`, a `KeyError` exception is raised.
-
-  ## Examples
-
-      iex> Map.update!(%{a: 1}, :a, &(&1 * 2))
-      %{a: 2}
-
-      iex> Map.update!(%{a: 1}, :b, &(&1 * 2))
-      ** (KeyError) key :b not found in: %{a: 1}
-
-  """
-  @spec update!(map, key, (value -> value)) :: map
-  def update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-    put(map, key, fun.(value))
-  end
-
-  @doc """
-  Gets the value from `key` and updates it, all in one pass.
-
-  `fun` is called with the current value under `key` in `map` (or `nil` if `key`
-  is not present in `map`) and must return a two-element tuple: the "get" value
-  (the retrieved value, which can be operated on before being returned) and the
-  new value to be stored under `key` in the resulting new map. `fun` may also
-  return `:pop`, which means the current value shall be removed from `map` and
-  returned (making this function behave like `Map.pop(map, key)`.
-
-  The returned value is a tuple with the "get" value returned by
-  `fun` and a new map with the updated value under `key`.
-
-  ## Examples
-
-      iex> Map.get_and_update(%{a: 1}, :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, %{a: "new value!"}}
-
-      iex> Map.get_and_update(%{a: 1}, :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {nil, %{b: "new value!", a: 1}}
-
-      iex> Map.get_and_update(%{a: 1}, :a, fn _ -> :pop end)
-      {1, %{}}
-
-      iex> Map.get_and_update(%{a: 1}, :b, fn _ -> :pop end)
-      {nil, %{a: 1}}
-
-  """
-  @spec get_and_update(map, key, (value -> {get, value} | :pop)) :: {get, map} when get: term
-  def get_and_update(map, key, fun) when is_function(fun, 1) do
-    current = get(map, key)
-
-    case fun.(current) do
-      {get, update} ->
-        {get, put(map, key, update)}
-      :pop ->
-        {current, delete(map, key)}
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
-    end
-  end
-
-  @doc """
-  Gets the value from `key` and updates it. Raises if there is no `key`.
-
-  Behaves exactly like `get_and_update/3`, but raises a `KeyError` exception if
-  `key` is not present in `map`.
-
-  ## Examples
-
-      iex> Map.get_and_update!(%{a: 1}, :a, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      {1, %{a: "new value!"}}
-
-      iex> Map.get_and_update!(%{a: 1}, :b, fn current_value ->
-      ...>   {current_value, "new value!"}
-      ...> end)
-      ** (KeyError) key :b not found in: %{a: 1}
-
-      iex> Map.get_and_update!(%{a: 1}, :a, fn _ ->
-      ...>   :pop
-      ...> end)
-      {1, %{}}
-
-  """
-  @spec get_and_update!(map, key, (value -> {get, value})) :: {get, map} | no_return when get: term
-  def get_and_update!(map, key, fun) when is_function(fun, 1) do
-    value = fetch!(map, key)
-
-    case fun.(value) do
-      {get, update} ->
-        {get, put(map, key, update)}
-      :pop ->
-        {value, delete(map, key)}
-      other ->
-        raise "the given function must return a two-element tuple or :pop, got: #{inspect(other)}"
-    end
-  end
-
-  @doc """
-  Converts a `struct` to map.
-
-  It accepts the struct module or a struct itself and
-  simply removes the `__struct__` field from the given struct
-  or from a new struct generated from the given module.
-
-  ## Example
-
-      defmodule User do
-        defstruct [:name]
-      end
-
-      Map.from_struct(User)
-      #=> %{name: nil}
-
-      Map.from_struct(%User{name: "john"})
-      #=> %{name: "john"}
-
-  """
-  @spec from_struct(atom | struct) :: map
-  def from_struct(struct) when is_atom(struct) do
-    delete(struct.__struct__(), :__struct__)
-  end
-
-  def from_struct(%_{} = struct) do
-    delete(struct, :__struct__)
-  end
-
-  @doc """
-  Checks if two maps are equal.
-
-  Two maps are considered to be equal if they contain
-  the same keys and those keys contain the same values.
-
-  ## Examples
-
-      iex> Map.equal?(%{a: 1, b: 2}, %{b: 2, a: 1})
-      true
-      iex> Map.equal?(%{a: 1, b: 2}, %{b: 1, a: 2})
-      false
-
-  """
-  @spec equal?(map, map) :: boolean
-  def equal?(map1, map2)
-
-  def equal?(%{} = map1, %{} = map2), do: map1 === map2
-  def equal?(%{} = map1, map2), do: :erlang.error({:badmap, map2}, [map1, map2])
-  def equal?(term, other), do: :erlang.error({:badmap, term}, [term, other])
-
-  @doc false
-  # TODO: Remove on 2.0
-  # (hard-deprecated in elixir_dispatch)
-  def size(map) do
-    map_size(map)
-  end
-end

lib/elixir/lib/map_set.ex

@@ -1,385 +0,0 @@
-defmodule MapSet do
-  @moduledoc """
-  Functions that work on sets.
-
-  `MapSet` is the "go to" set data structure in Elixir. A set can be constructed
-  using `MapSet.new/0`:
-
-      iex> MapSet.new
-      #MapSet<[]>
-
-  A set can contain any kind of elements, and elements in a set don't have to be
-  of the same type. By definition, sets can't contain duplicate elements: when
-  inserting an element in a set where it's already present, the insertion is
-  simply a no-op.
-
-      iex> map_set = MapSet.new
-      iex> MapSet.put(map_set, "foo")
-      #MapSet<["foo"]>
-      iex> map_set |> MapSet.put("foo") |> MapSet.put("foo")
-      #MapSet<["foo"]>
-
-  A `MapSet` is represented internally using the `%MapSet{}` struct. This struct
-  can be used whenever there's a need to pattern match on something being a `MapSet`:
-
-      iex> match?(%MapSet{}, MapSet.new())
-      true
-
-  Note that, however, the struct fields are private and must not be accessed
-  directly; use the functions in this module to perform operations on sets.
-
-  `MapSet`s can also be constructed starting from other collection-type data
-  structures: for example, see `MapSet.new/1` or `Enum.into/2`.
-  """
-
-  @type value :: term
-
-  @opaque t(value) :: %__MODULE__{map: %{optional(value) => []}}
-  @type t :: t(term)
-
-  defstruct map: %{}, version: 2
-
-  @doc """
-  Returns a new set.
-
-  ## Examples
-
-      iex> MapSet.new
-      #MapSet<[]>
-
-  """
-  @spec new :: t
-  def new(), do: %MapSet{}
-
-  @doc """
-  Creates a set from an enumerable.
-
-  ## Examples
-
-      iex> MapSet.new([:b, :a, 3])
-      #MapSet<[3, :a, :b]>
-      iex> MapSet.new([3, 3, 3, 2, 2, 1])
-      #MapSet<[1, 2, 3]>
-
-  """
-  @spec new(Enum.t) :: t
-  def new(enumerable)
-
-  def new(%__MODULE__{} = map_set), do: map_set
-  def new(enumerable) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> new_from_list([])
-
-    %MapSet{map: map}
-  end
-
-  @doc """
-  Creates a set from an enumerable via the transformation function.
-
-  ## Examples
-
-      iex> MapSet.new([1, 2, 1], fn x -> 2 * x end)
-      #MapSet<[2, 4]>
-
-  """
-  @spec new(Enum.t, (term -> val)) :: t(val) when val: value
-  def new(enumerable, transform) when is_function(transform, 1) do
-    map =
-      enumerable
-      |> Enum.to_list
-      |> new_from_list_transform(transform, [])
-
-    %MapSet{map: map}
-  end
-
-  defp new_from_list([], acc) do
-    :maps.from_list(acc)
-  end
-
-  defp new_from_list([item | rest], acc) do
-    new_from_list(rest, [{item, []} | acc])
-  end
-
-  defp new_from_list_transform([], _fun, acc) do
-    :maps.from_list(acc)
-  end
-  defp new_from_list_transform([item | rest], fun, acc) do
-    new_from_list_transform(rest, fun, [{fun.(item), []} | acc])
-  end
-
-  @doc """
-  Deletes `value` from `map_set`.
-
-  Returns a new set which is a copy of `map_set` but without `value`.
-
-  ## Examples
-
-      iex> map_set = MapSet.new([1, 2, 3])
-      iex> MapSet.delete(map_set, 4)
-      #MapSet<[1, 2, 3]>
-      iex> MapSet.delete(map_set, 2)
-      #MapSet<[1, 3]>
-
-  """
-  @spec delete(t(val1), val2) :: t(val1) when val1: value, val2: value
-  def delete(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.delete(map, value)}
-  end
-
-  @doc """
-  Returns a set that is `map_set1` without the members of `map_set2`.
-
-  ## Examples
-
-      iex> MapSet.difference(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[1]>
-
-  """
-  @spec difference(t(val1), t(val2)) :: t(val1) when val1: value, val2: value
-  def difference(map_set1, map_set2)
-
-  # If the first set is less than twice the size of the second map,
-  # it is fastest to re-accumulate items in the first set that are not
-  # present in the second set.
-  def difference(%MapSet{map: map1}, %MapSet{map: map2})
-      when map_size(map1) < map_size(map2) * 2 do
-    map =
-      map1
-      |> Map.keys
-      |> filter_not_in(map2)
-
-    %MapSet{map: map}
-  end
-
-  # If the second set is less than half the size of the first set, it's fastest
-  # to simply iterate through each item in the second set, deleting them from
-  # the first set.
-  def difference(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
-    %{map_set | map: Map.drop(map1, Map.keys(map2))}
-  end
-
-  defp filter_not_in(keys, map2, acc \\ [])
-  defp filter_not_in([], _map2, acc), do: :maps.from_list(acc)
-  defp filter_not_in([key | rest], map2, acc) do
-    acc =
-      if Map.has_key?(map2, key) do
-        acc
-      else
-        [{key, []} | acc]
-      end
-    filter_not_in(rest, map2, acc)
-  end
-
-  @doc """
-  Checks if `map_set1` and `map_set2` have no members in common.
-
-  ## Examples
-
-      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      true
-      iex> MapSet.disjoint?(MapSet.new([1, 2]), MapSet.new([2, 3]))
-      false
-
-  """
-  @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
-  end
-
-  @doc """
-  Checks if two sets are equal.
-
-  The comparison between elements must be done using `===`.
-
-  ## Examples
-
-      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([2, 1, 1]))
-      true
-      iex> MapSet.equal?(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      false
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(%MapSet{map: map1, version: version}, %MapSet{map: map2, version: version}) do
-    Map.equal?(map1, map2)
-  end
-
-  # Elixir v1.5 change the map representation, so on
-  # version mismatch we need to compare the keys directly.
-  def equal?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    map_size(map1) == map_size(map2) and map_subset?(Map.keys(map1), map2)
-  end
-
-  @doc """
-  Returns a set containing only members that `map_set1` and `map_set2` have in common.
-
-  ## Examples
-
-      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[2]>
-
-      iex> MapSet.intersection(MapSet.new([1, 2]), MapSet.new([3, 4]))
-      #MapSet<[]>
-
-  """
-  @spec intersection(t(val), t(val)) :: t(val) when val: value
-  def intersection(%MapSet{map: map1} = map_set, %MapSet{map: map2}) do
-    {map1, map2} = order_by_size(map1, map2)
-    %{map_set | map: Map.take(map2, Map.keys(map1))}
-  end
-
-  @doc """
-  Checks if `map_set` contains `value`.
-
-  ## Examples
-
-      iex> MapSet.member?(MapSet.new([1, 2, 3]), 2)
-      true
-      iex> MapSet.member?(MapSet.new([1, 2, 3]), 4)
-      false
-
-  """
-  @spec member?(t, value) :: boolean
-  def member?(%MapSet{map: map}, value) do
-    Map.has_key?(map, value)
-  end
-
-  @doc """
-  Inserts `value` into `map_set` if `map_set` doesn't already contain it.
-
-  ## Examples
-
-      iex> MapSet.put(MapSet.new([1, 2, 3]), 3)
-      #MapSet<[1, 2, 3]>
-      iex> MapSet.put(MapSet.new([1, 2, 3]), 4)
-      #MapSet<[1, 2, 3, 4]>
-
-  """
-  @spec put(t(val), new_val) :: t(val | new_val) when val: value, new_val: value
-  def put(%MapSet{map: map} = map_set, value) do
-    %{map_set | map: Map.put(map, value, [])}
-  end
-
-  @doc """
-  Returns the number of elements in `map_set`.
-
-  ## Examples
-
-      iex> MapSet.size(MapSet.new([1, 2, 3]))
-      3
-
-  """
-  @spec size(t) :: non_neg_integer
-  def size(%MapSet{map: map}) do
-    map_size(map)
-  end
-
-  @doc """
-  Checks if `map_set1`'s members are all contained in `map_set2`.
-
-  This function checks if `map_set1` is a subset of `map_set2`.
-
-  ## Examples
-
-      iex> MapSet.subset?(MapSet.new([1, 2]), MapSet.new([1, 2, 3]))
-      true
-      iex> MapSet.subset?(MapSet.new([1, 2, 3]), MapSet.new([1, 2]))
-      false
-
-  """
-  @spec subset?(t, t) :: boolean
-  def subset?(%MapSet{map: map1}, %MapSet{map: map2}) do
-    if map_size(map1) <= map_size(map2) do
-      map1
-      |> Map.keys
-      |> map_subset?(map2)
-    else
-      false
-    end
-  end
-
-  defp map_subset?([], _), do: true
-  defp map_subset?([key | rest], map2) do
-    if Map.has_key?(map2, key) do
-      map_subset?(rest, map2)
-    else
-      false
-    end
-  end
-
-  @doc """
-  Converts `map_set` to a list.
-
-  ## Examples
-
-      iex> MapSet.to_list(MapSet.new([1, 2, 3]))
-      [1, 2, 3]
-
-  """
-  @spec to_list(t(val)) :: [val] when val: value
-  def to_list(%MapSet{map: map}) do
-    Map.keys(map)
-  end
-
-  @doc """
-  Returns a set containing all members of `map_set1` and `map_set2`.
-
-  ## Examples
-
-      iex> MapSet.union(MapSet.new([1, 2]), MapSet.new([2, 3, 4]))
-      #MapSet<[1, 2, 3, 4]>
-
-  """
-  @spec union(t(val1), t(val2)) :: t(val1 | val2) when val1: value, val2: value
-  def union(map_set1, map_set2)
-
-  def union(%MapSet{map: map1, version: version} = map_set, %MapSet{map: map2, version: version}) do
-    %{map_set | map: Map.merge(map1, map2)}
-  end
-  def union(%MapSet{map: map1}, %MapSet{map: map2}) do
-    new_from_list(Map.keys(map1) ++ Map.keys(map2), [])
-  end
-
-  defp order_by_size(map1, map2) when map_size(map1) > map_size(map2), do: {map2, map1}
-  defp order_by_size(map1, map2), do: {map1, map2}
-
-  defimpl Enumerable do
-    def reduce(map_set, acc, fun), do: Enumerable.List.reduce(MapSet.to_list(map_set), acc, fun)
-    def member?(map_set, val), do: {:ok, MapSet.member?(map_set, val)}
-    def count(map_set), do: {:ok, MapSet.size(map_set)}
-  end
-
-  defimpl Collectable do
-    def into(original) do
-      {original, fn
-        map_set, {:cont, x} -> MapSet.put(map_set, x)
-        map_set, :done -> map_set
-        _, :halt -> :ok
-      end}
-    end
-  end
-
-  defimpl Inspect do
-    import Inspect.Algebra
-
-    def inspect(map_set, opts) do
-      concat ["#MapSet<", Inspect.List.inspect(MapSet.to_list(map_set), opts), ">"]
-    end
-  end
-end

lib/elixir/lib/module/locals_tracker.ex

@@ -1,327 +0,0 @@
-# This is an Elixir module responsible for tracking
-# calls in order to extract Elixir modules' behaviour
-# during compilation time.
-#
-# ## Implementation
-#
-# The implementation uses the digraph module to track
-# all dependencies. The graph starts with one main vertex:
-#
-# * `:local` - points to local functions
-#
-# We can also have the following vertices:
-#
-# * `Module` - a module that was invoked via an import
-# * `{name, arity}` - a local function/arity pair
-# * `{:import, name, arity}` - an invoked function/arity import
-#
-# Each of those vertices can associate to other vertices
-# as described below:
-#
-# * `Module`
-#   * in neighbours:  `{:import, name, arity}`
-#
-# * `{name, arity}`
-#   * in neighbours: `:local`, `{name, arity}`
-#   * out neighbours: `{:import, name, arity}`
-#
-# * `{:import, name, arity}`
-#   * in neighbours: `{name, arity}`
-#   * out neighbours: `Module`
-#
-# Note that since this is required for bootstrap, we can't use
-# any of the `GenServer` conveniences.
-defmodule Module.LocalsTracker do
-  @moduledoc false
-
-  @timeout   30_000
-  @behaviour :gen_server
-
-  @type ref :: pid | module
-  @type name :: atom
-  @type name_arity :: {name, arity}
-
-  @type local :: {name, arity}
-  @type import :: {:import, name, arity}
-
-  # Public API
-
-  @doc """
-  Returns all imported modules that had the given
-  `{name, arity}` invoked.
-  """
-  @spec imports_with_dispatch(ref, name_arity) :: [module]
-  def imports_with_dispatch(ref, {name, arity}) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, {:import, name, arity})
-  end
-
-  @doc """
-  Returns all locals that are reachable.
-
-  By default, all public functions are reachable.
-  A private function is only reachable if it has
-  a public function that it invokes directly.
-  """
-  @spec reachable(ref) :: [local]
-  def reachable(ref) do
-    ref
-    |> to_pid()
-    |> :gen_server.call(:digraph, @timeout)
-    |> reachable_from(:local)
-    |> :sets.to_list()
-  end
-
-  defp reachable_from(d, starting) do
-    reduce_reachable(d, starting, :sets.new)
-  end
-
-  defp reduce_reachable(d, vertex, vertices) do
-    neighbours = :digraph.out_neighbours(d, vertex)
-    neighbours = (for {_, _} = t <- neighbours, do: t) |> :sets.from_list
-    remaining  = :sets.subtract(neighbours, vertices)
-    vertices   = :sets.union(neighbours, vertices)
-    :sets.fold(&reduce_reachable(d, &1, &2), vertices, remaining)
-  end
-
-  defp to_pid(pid) when is_pid(pid),  do: pid
-  defp to_pid(mod) when is_atom(mod) do
-    table = :elixir_module.data_table(mod)
-    :ets.lookup_element(table, {:elixir, :locals_tracker}, 2)
-  end
-
-  # Internal API
-
-  # Starts the tracker and returns its PID.
-  @doc false
-  def start_link do
-    :gen_server.start_link(__MODULE__, [], [])
-  end
-
-  # Adds a definition into the tracker. A public
-  # definition is connected with the :local node
-  # while a private one is left unreachable until
-  # a call is made to.
-  @doc false
-  def add_definition(pid, kind, tuple) when kind in [:def, :defp, :defmacro, :defmacrop] do
-    :gen_server.cast(pid, {:add_definition, kind, tuple})
-  end
-
-  # Adds and tracks defaults for a definition into the tracker.
-  @doc false
-  def add_defaults(pid, kind, tuple, defaults) when kind in [:def, :defp, :defmacro, :defmacrop] do
-    :gen_server.cast(pid, {:add_defaults, kind, tuple, defaults})
-  end
-
-  # Adds a local dispatch to the given target.
-  def add_local(pid, to) when is_tuple(to) do
-    :gen_server.cast(pid, {:add_local, :local, to})
-  end
-
-  # Adds a local dispatch from-to the given target.
-  @doc false
-  def add_local(pid, from, to) when is_tuple(from) and is_tuple(to) do
-    :gen_server.cast(pid, {:add_local, from, to})
-  end
-
-  # Adds an import dispatch to the given target.
-  @doc false
-  def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
-    :gen_server.cast(pid, {:add_import, function, module, target})
-  end
-
-  # Yanks a local node. Returns its in and out vertices in a tuple.
-  @doc false
-  def yank(pid, local) do
-    :gen_server.call(to_pid(pid), {:yank, local}, @timeout)
-  end
-
-  # Reattach a previously yanked node
-  @doc false
-  def reattach(pid, kind, tuple, neighbours) do
-    :gen_server.cast(to_pid(pid), {:reattach, kind, tuple, neighbours})
-  end
-
-  # Collecting all conflicting imports with the given functions
-  @doc false
-  def collect_imports_conflicts(pid, all_defined) do
-    d = :gen_server.call(pid, :digraph, @timeout)
-
-    for {{name, arity}, _, meta, _} <- all_defined,
-        :digraph.in_neighbours(d, {:import, name, arity}) != [],
-        n = :digraph.out_neighbours(d, {:import, name, arity}),
-        n != [] do
-      {meta, {n, name, arity}}
-    end
-  end
-
-  # Collect all unused definitions based on the private
-  # given also accounting the expected amount of default
-  # clauses a private function have.
-  @doc false
-  def collect_unused_locals(ref, private) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    reachable = reachable_from(d, :local)
-    {unreachable(reachable, private), collect_warnings(reachable, private)}
-  end
-
-  defp unreachable(reachable, private) do
-    for {tuple, _, _, _} <- private,
-        not :sets.is_element(tuple, reachable),
-        do: tuple
-  end
-
-  defp collect_warnings(reachable, private) do
-    :lists.foldl(&collect_warnings(&1, &2, reachable), [], private)
-  end
-
-  defp collect_warnings({_, _, false, _}, acc, _reachable) do
-    acc
-  end
-
-  defp collect_warnings({tuple, kind, meta, 0}, acc, reachable) do
-    if :sets.is_element(tuple, reachable) do
-      acc
-    else
-      [{meta, {:unused_def, tuple, kind}} | acc]
-    end
-  end
-
-  defp collect_warnings({tuple, kind, meta, default}, acc, reachable) when default > 0 do
-    {name, arity} = tuple
-    min = arity - default
-    max = arity
-
-    case min_reachable_default(max, min, :none, name, reachable) do
-      :none -> [{meta, {:unused_def, tuple, kind}} | acc]
-      ^min -> acc
-      ^max -> [{meta, {:unused_args, tuple}} | acc]
-      diff -> [{meta, {:unused_args, tuple, diff}} | acc]
-    end
-  end
-
-  defp min_reachable_default(max, min, last, name, reachable) when max >= min do
-    case :sets.is_element({name, max}, reachable) do
-      true -> min_reachable_default(max - 1, min, max, name, reachable)
-      false -> min_reachable_default(max - 1, min, last, name, reachable)
-    end
-  end
-  defp min_reachable_default(_max, _min, last, _name, _reachable) do
-    last
-  end
-
-  # Stops the gen server
-  @doc false
-  def stop(pid) do
-    :gen_server.cast(pid, :stop)
-  end
-
-  # Callbacks
-
-  def init([]) do
-    d = :digraph.new([:protected])
-    :digraph.add_vertex(d, :local)
-    {:ok, d}
-  end
-
-  def handle_call({:yank, local}, _from, d) do
-    out_vertices = :digraph.out_neighbours(d, local)
-    :digraph.del_edges(d, :digraph.out_edges(d, local))
-    {:reply, {[], out_vertices}, d}
-  end
-
-  def handle_call(:digraph, _from, d) do
-    {:reply, d, d}
-  end
-
-  @doc false
-  def handle_info(_msg, d) do
-    {:noreply, d}
-  end
-
-  def handle_cast({:add_local, from, to}, d) do
-    handle_add_local(d, from, to)
-    {:noreply, d}
-  end
-
-  def handle_cast({:add_import, function, module, {name, arity}}, d) do
-    handle_import(d, function, module, name, arity)
-    {:noreply, d}
-  end
-
-  def handle_cast({:add_definition, kind, tuple}, d) do
-    handle_add_definition(d, kind, tuple)
-    {:noreply, d}
-  end
-
-  def handle_cast({:add_defaults, kind, {name, arity}, defaults}, d) do
-    for i <- :lists.seq(arity - defaults, arity - 1) do
-      handle_add_definition(d, kind, {name, i})
-      handle_add_local(d, {name, i}, {name, arity})
-    end
-    {:noreply, d}
-  end
-
-  def handle_cast({:reattach, _kind, tuple, {in_neigh, out_neigh}}, d) do
-    for from <- in_neigh do
-      :digraph.add_vertex(d, from)
-      replace_edge!(d, from, tuple)
-    end
-
-    for to <- out_neigh do
-      :digraph.add_vertex(d, to)
-      replace_edge!(d, tuple, to)
-    end
-
-    {:noreply, d}
-  end
-
-  def handle_cast(:stop, d) do
-    {:stop, :normal, d}
-  end
-
-  @doc false
-  def terminate(_reason, _state) do
-    :ok
-  end
-
-  @doc false
-  def code_change(_old, state, _extra) do
-    {:ok, state}
-  end
-
-  defp handle_import(d, function, module, name, arity) do
-    :digraph.add_vertex(d, module)
-
-    tuple = {:import, name, arity}
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, tuple, module)
-
-    if function != nil do
-      replace_edge!(d, function, tuple)
-    end
-
-    :ok
-  end
-
-  defp handle_add_local(d, from, to) do
-    :digraph.add_vertex(d, to)
-    replace_edge!(d, from, to)
-  end
-
-  defp handle_add_definition(d, public, tuple) when public in [:def, :defmacro] do
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, :local, tuple)
-  end
-
-  defp handle_add_definition(d, private, tuple) when private in [:defp, :defmacrop] do
-    :digraph.add_vertex(d, tuple)
-  end
-
-  defp replace_edge!(d, from, to) do
-    _ = unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      [:"$e" | _] = :digraph.add_edge(d, from, to)
-    end
-    :ok
-  end
-end

lib/elixir/lib/node.ex

@@ -1,273 +0,0 @@
-defmodule Node do
-  @moduledoc """
-  Functions related to VM nodes.
-
-  Some of the functions in this module are inlined by the compiler,
-  similar to functions in the `Kernel` module and they are explicitly
-  marked in their docs as "inlined by the compiler". For more information
-  about inlined functions, check out the `Kernel` module.
-  """
-
-  @type t :: node
-
-  @doc """
-  Turns a non-distributed node into a distributed node.
-
-  This functionality starts the `:net_kernel` and other
-  related processes.
-  """
-  @spec start(node, :longnames | :shortnames, non_neg_integer) ::
-             {:ok, pid} | {:error, term}
-  def start(name, type \\ :longnames, tick_time \\ 15000) do
-    :net_kernel.start([name, type, tick_time])
-  end
-
-  @doc """
-  Turns a distributed node into a non-distributed node.
-
-  For other nodes in the network, this is the same as the node going down.
-  Only possible when the node was started with `Node.start/3`, otherwise
-  returns `{:error, :not_allowed}`. Returns `{:error, :not_found}` if the
-  local node is not alive.
-  """
-  @spec stop() :: :ok | {:error, :not_allowed | :not_found}
-  def stop() do
-    :net_kernel.stop()
-  end
-
-  @doc """
-  Returns the current node.
-
-  It returns the same as the built-in `node()`.
-  """
-  @spec self :: t
-  def self do
-    :erlang.node()
-  end
-
-  @doc """
-  Returns `true` if the local node is alive.
-
-  That is, if the node can be part of a distributed system.
-  """
-  @spec alive? :: boolean
-  def alive? do
-    :erlang.is_alive()
-  end
-
-  @doc """
-  Returns a list of all visible nodes in the system, excluding
-  the local node.
-
-  Same as `list(:visible)`.
-  """
-  @spec list :: [t]
-  def list do
-    :erlang.nodes()
-  end
-
-  @doc """
-  Returns a list of nodes according to argument given.
-
-  The result returned when the argument is a list, is the list of nodes
-  satisfying the disjunction(s) of the list elements.
-
-  For more information, see
-  [`:erlang.nodes/1`](http://www.erlang.org/doc/man/erlang.html#nodes-1).
-  """
-  @typep state :: :visible | :hidden | :connected | :this | :known
-  @spec list(state | [state]) :: [t]
-  def list(args) do
-    :erlang.nodes(args)
-  end
-
-  @doc """
-  Monitors the status of the node.
-
-  If `flag` is `true`, monitoring is turned on.
-  If `flag` is `false`, monitoring is turned off.
-
-  For more information, see
-  [`:erlang.monitor_node/2`](http://www.erlang.org/doc/man/erlang.html#monitor_node-2).
-  
-  For monitoring status changes of all nodes, see
-  [`:net_kernel.monitor_nodes/3`](http://www.erlang.org/doc/man/net_kernel.html#monitor_nodes-2).
-  """
-  @spec monitor(t, boolean) :: true
-  def monitor(node, flag) do
-    :erlang.monitor_node(node, flag)
-  end
-
-  @doc """
-  Behaves as `monitor/2` except that it allows an extra
-  option to be given, namely `:allow_passive_connect`.
-
-  For more information, see
-  [`:erlang.monitor_node/3`](http://www.erlang.org/doc/man/erlang.html#monitor_node-3).
-  
-  For monitoring status changes of all nodes, see
-  [`:net_kernel.monitor_nodes/3`](http://www.erlang.org/doc/man/net_kernel.html#monitor_nodes-2).
-  """
-  @spec monitor(t, boolean, [:allow_passive_connect]) :: true
-  def monitor(node, flag, options) do
-    :erlang.monitor_node(node, flag, options)
-  end
-
-  @doc """
-  Tries to set up a connection to node.
-
-  Returns `:pang` if it fails, or `:pong` if it is successful.
-
-  ## Examples
-
-      iex> Node.ping(:unknown_node)
-      :pang
-
-  """
-  @spec ping(t) :: :pong | :pang
-  def ping(node) do
-    :net_adm.ping(node)
-  end
-
-  @doc """
-  Forces the disconnection of a node.
-
-  This will appear to the `node` as if the local node has crashed.
-  This function is mainly used in the Erlang network authentication
-  protocols. Returns `true` if disconnection succeeds, otherwise `false`.
-  If the local node is not alive, the function returns `:ignored`.
-
-  For more information, see
-  [`:erlang.disconnect_node/1`](http://www.erlang.org/doc/man/erlang.html#disconnect_node-1).
-  """
-  @spec disconnect(t) :: boolean | :ignored
-  def disconnect(node) do
-    :erlang.disconnect_node(node)
-  end
-
-  @doc """
-  Establishes a connection to `node`.
-
-  Returns `true` if successful, `false` if not, and the atom
-  `:ignored` if the local node is not alive.
-
-  For more information, see
-  [`:net_kernel.connect_node/1`](http://www.erlang.org/doc/man/net_kernel.html#connect_node-1).
-  """
-  @spec connect(t) :: boolean | :ignored
-  def connect(node) do
-    :net_kernel.connect_node(node)
-  end
-
-  @doc """
-  Returns the PID of a new process started by the application of `fun`
-  on `node`. If `node` does not exist, a useless PID is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn/2`](http://www.erlang.org/doc/man/erlang.html#spawn-2).
-
-  Inlined by the compiler.
-  """
-  @spec spawn(t, (() -> any)) :: pid
-  def spawn(node, fun) do
-    :erlang.spawn(node, fun)
-  end
-
-  @doc """
-  Returns the PID of a new process started by the application of `fun`
-  on `node`.
-
-  If `node` does not exist, a useless PID is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn_opt/3`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-3).
-
-  Inlined by the compiler.
-  """
-  @spec spawn(t, (() -> any), Process.spawn_opts) :: pid | {pid, reference}
-  def spawn(node, fun, opts) do
-    :erlang.spawn_opt(node, fun, opts)
-  end
-
-  @doc """
-  Returns the PID of a new process started by the application of
-  `module.function(args)` on `node`.
-
-  If `node` does not exist, a useless PID is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn/4`](http://www.erlang.org/doc/man/erlang.html#spawn-4).
-
-  Inlined by the compiler.
-  """
-  @spec spawn(t, module, atom, [any]) :: pid
-  def spawn(node, module, fun, args) do
-    :erlang.spawn(node, module, fun, args)
-  end
-
-  @doc """
-  Returns the PID of a new process started by the application of
-  `module.function(args)` on `node`.
-
-  If `node` does not exist, a useless PID is returned.
-
-  For the list of available options, see
-  [`:erlang.spawn/5`](http://www.erlang.org/doc/man/erlang.html#spawn_opt-5).
-
-  Inlined by the compiler.
-  """
-  @spec spawn(t, module, atom, [any], Process.spawn_opts) :: pid | {pid, reference}
-  def spawn(node, module, fun, args, opts) do
-    :erlang.spawn_opt(node, module, fun, args, opts)
-  end
-
-  @doc """
-  Returns the PID of a new linked process started by the application of `fun` on `node`.
-
-  A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless PID is returned (and due to the link, an exit
-  signal with exit reason `:noconnection` will be received).
-
-  Inlined by the compiler.
-  """
-  @spec spawn_link(t, (() -> any)) :: pid
-  def spawn_link(node, fun) do
-    :erlang.spawn_link(node, fun)
-  end
-
-  @doc """
-  Returns the PID of a new linked process started by the application of
-  `module.function(args)` on `node`.
-
-  A link is created between the calling process and the new process, atomically.
-  If `node` does not exist, a useless PID is returned (and due to the link, an exit
-  signal with exit reason `:noconnection` will be received).
-
-  Inlined by the compiler.
-  """
-  @spec spawn_link(t, module, atom, [any]) :: pid
-  def spawn_link(node, module, fun, args) do
-    :erlang.spawn_link(node, module, fun, args)
-  end
-
-  @doc """
-  Sets the magic cookie of `node` to the atom `cookie`.
-
-  The default node is `Node.self/0`, the local node. If `node` is the local node,
-  the function also sets the cookie of all other unknown nodes to `cookie`.
-
-  This function will raise `FunctionClauseError` if the given `node` is not alive.
-  """
-  def set_cookie(node \\ Node.self, cookie) when is_atom(cookie) do
-    :erlang.set_cookie(node, cookie)
-  end
-
-  @doc """
-  Returns the magic cookie of the local node.
-
-  Returns the cookie if the node is alive, otherwise `:nocookie`.
-  """
-  def get_cookie() do
-    :erlang.get_cookie()
-  end
-end

lib/elixir/lib/option_parser.ex

@@ -1,760 +0,0 @@
-defmodule OptionParser do
-  @moduledoc """
-  This module contains functions to parse command line options.
-  """
-
-  @type argv    :: [String.t]
-  @type parsed  :: keyword
-  @type errors  :: [{String.t, String.t | nil}]
-  @type options :: [switches: keyword, strict: keyword, aliases: keyword]
-
-  defmodule ParseError do
-    defexception [:message]
-  end
-
-  @doc """
-  Parses `argv` into a keyword list.
-
-  It returns a three-element tuple with the form `{parsed, args, invalid}`, where:
-
-    * `parsed` is a keyword list of parsed switches with `{switch_name, value}`
-      tuples in it; `switch_name` is the atom representing the switch name while
-      `value` is the value for that switch parsed according to `opts` (see the
-      "Examples" section for more information)
-    * `args` is a list of the remaining arguments in `argv` as strings
-    * `invalid` is a list of invalid options as `{option_name, value}` where
-      `option_name` is the raw option and `value` is `nil` if the option wasn't
-      expected or the string value if the value didn't have the expected type for
-      the corresponding option
-
-  Elixir converts switches to underscored atoms, so `--source-path` becomes
-  `:source_path`. This is done to better suit Elixir conventions. However, this
-  means that switches can't contain underscores and switches that do contain
-  underscores are always returned in the list of invalid switches.
-
-  When parsing, it is common to list switches and their expected types:
-
-      iex> OptionParser.parse(["--debug"], switches: [debug: :boolean])
-      {[debug: true], [], []}
-
-      iex> OptionParser.parse(["--source", "lib"], switches: [source: :string])
-      {[source: "lib"], [], []}
-
-      iex> OptionParser.parse(["--source-path", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                    switches: [source_path: :string, verbose: :boolean])
-      {[source_path: "lib", verbose: true], ["test/enum_test.exs"], []}
-
-  We will explore the valid switches and operation modes of option parser below.
-
-  ## Options
-
-  The following options are supported:
-
-    * `:switches` or `:strict` - see the "Switch definitions" section below
-    * `:allow_nonexistent_atoms` - see the "Parsing dynamic switches" section below
-    * `:aliases` - see the "Aliases" section below
-
-  ## Switch definitions
-
-  Switches can be specified via one of two options:
-
-    * `:switches` - defines some switches and their types. This function
-      still attempts to parse switches that are not in this list.
-    * `:strict` - defines strict switches. Any switch in `argv` that is not
-      specified in the list is returned in the invalid options list.
-
-  Both these options accept a keyword list of `{name, type}` tuples where `name`
-  is an atom defining the name of the switch and `type` is an atom that
-  specifies the type for the value of this switch (see the "Types" section below
-  for the possible types and more information about type casting).
-
-  Note that you should only supply the `:switches` or the`:strict` option.
-  If you supply both, an `ArgumentError` exception will be raised.
-
-  ### Types
-
-  Switches parsed by `OptionParser` may take zero or one arguments.
-
-  The following switches types take no arguments:
-
-    * `:boolean` - sets the value to `true` when given (see also the
-      "Negation switches" section below)
-    * `:count` - counts the number of times the switch is given
-
-  The following switches take one argument:
-
-    * `:integer` - parses the value as an integer
-    * `:float` - parses the value as a float
-    * `:string` - parses the value as a string
-
-  If a switch can't be parsed according to the given type, it is
-  returned in the invalid options list.
-
-  ### Modifiers
-
-  Switches can be specified with modifiers, which change how
-  they behave. The following modifiers are supported:
-
-    * `:keep` - keeps duplicated items instead of overriding them;
-      works with all types except `:count`. Specifying `switch_name: :keep`
-      assumes the type of `:switch_name` will be `:string`.
-
-  To use `:keep` with a type other than `:string`, use a list as the type
-  for the switch. For example: `[foo: [:integer, :keep]]`.
-
-  ### Negation switches
-
-  In case a switch `SWITCH` is specified to have type `:boolean`, it may be
-  passed as `--no-SWITCH` as well which will set the option to `false`:
-
-      iex> OptionParser.parse(["--no-op", "path/to/file"], switches: [op: :boolean])
-      {[op: false], ["path/to/file"], []}
-
-  ### Parsing dynamic switches
-
-  `OptionParser` also includes a dynamic mode where it will attempt to parse
-  switches dynamically. Such can be done by not specifying the `:switches` or
-  `:strict` option.
-
-      iex> OptionParser.parse(["--debug"])
-      {[debug: true], [], []}
-
-
-  Switches followed by a value will be assigned the value, as a string. Switches
-  without an argument, like `--debug` in the examples above, will automatically be
-  set to `true`.
-
-  Since Elixir converts switches to atoms, the dynamic mode will only parse
-  switches that translate to atoms used by the runtime. Therefore, the code below
-  likely won't parse the given option since the `:option_parser_example` atom is
-  never used anywhere:
-
-      OptionParser.parse(["--option-parser-example"])
-      # The :option_parser_example atom is not used anywhere below
-
-  However, the code below does since the `:option_parser_example` atom is used
-  at some point later (or earlier) on:
-
-      {opts, _, _} = OptionParser.parse(["--option-parser-example"])
-      opts[:option_parser_example]
-
-  In other words, when using dynamic mode, Elixir will do the correct thing and
-  only parse options that are used by the runtime, ignoring all others. If you
-  would like to parse all switches, regardless if they exist or not, you can
-  force creation of atoms by passing `allow_nonexistent_atoms: true` as option.
-  Such option is useful when you are building command-line applications that
-  receive dynamically-named arguments but must be used with care on long-running
-  systems.
-
-  Switches followed by a value will be assigned the value, as a string.
-  Switches without an argument, like `--debug` in the examples above, will
-  automatically be set to `true`.
-
-  ## Aliases
-
-  A set of aliases can be specified in the `:aliases` option:
-
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
-      {[debug: true], [], []}
-
-  ## Examples
-
-  Here are some examples of working with different types and modifiers:
-
-      iex> OptionParser.parse(["--unlock", "path/to/file"], strict: [unlock: :boolean])
-      {[unlock: true], ["path/to/file"], []}
-
-      iex> OptionParser.parse(["--unlock", "--limit", "0", "path/to/file"],
-      ...>                    strict: [unlock: :boolean, limit: :integer])
-      {[unlock: true, limit: 0], ["path/to/file"], []}
-
-      iex> OptionParser.parse(["--limit", "3"], strict: [limit: :integer])
-      {[limit: 3], [], []}
-
-      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}]}
-
-      iex> OptionParser.parse(["--limit", "3", "--unknown", "xyz"],
-      ...>                    switches: [limit: :integer])
-      {[limit: 3, unknown: "xyz"], [], []}
-
-      iex> OptionParser.parse(["--unlock", "path/to/file", "--unlock", "path/to/another/file"], strict: [unlock: :keep])
-      {[unlock: "path/to/file", unlock: "path/to/another/file"], [], []}
-
-  """
-  @spec parse(argv, options) :: {parsed, argv, errors}
-  def parse(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    do_parse(argv, build_config(opts), [], [], [], true)
-  end
-
-  @doc """
-  The same as `parse/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there are no errors, returns a `{parsed, rest}` tuple where:
-
-    * `parsed` is the list of parsed switches (same as in `parse/2`)
-    * `rest` is the list of arguments (same as in `parse/2`)
-
-  ## Examples
-
-      iex> OptionParser.parse!(["--debug", "path/to/file"], strict: [debug: :boolean])
-      {[debug: true], ["path/to/file"]}
-
-      iex> OptionParser.parse!(["--limit", "xyz"], strict: [limit: :integer])
-      ** (OptionParser.ParseError) 1 error found!
-      --limit : Expected type integer, got "xyz"
-
-      iex> OptionParser.parse!(["--unknown", "xyz"], strict: [])
-      ** (OptionParser.ParseError) 1 error found!
-      --unknown : Unknown option
-
-      iex> OptionParser.parse!(["-l", "xyz", "-f", "bar"],
-      ...>                     switches: [limit: :integer, foo: :integer], aliases: [l: :limit, f: :foo])
-      ** (OptionParser.ParseError) 2 errors found!
-      -l : Expected type integer, got "xyz"
-      -f : Expected type integer, got "bar"
-
-  """
-  @spec parse!(argv, options) :: {parsed, argv} | no_return
-  def parse!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
-  @doc """
-  Similar to `parse/2` but only parses the head of `argv`;
-  as soon as it finds a non-switch, it stops parsing.
-
-  See `parse/2` for more information.
-
-  ## Example
-
-      iex> OptionParser.parse_head(["--source", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                         switches: [source: :string, verbose: :boolean])
-      {[source: "lib"], ["test/enum_test.exs", "--verbose"], []}
-
-      iex> OptionParser.parse_head(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
-      ...>                         switches: [source: :string, verbose: :boolean, unlock: :boolean])
-      {[verbose: true, source: "lib"], ["test/enum_test.exs", "--unlock"], []}
-
-  """
-  @spec parse_head(argv, options) :: {parsed, argv, errors}
-  def parse_head(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    do_parse(argv, build_config(opts), [], [], [], false)
-  end
-
-  @doc """
-  The same as `parse_head/2` but raises an `OptionParser.ParseError`
-  exception if any invalid options are given.
-
-  If there are no errors, returns a `{parsed, rest}` tuple where:
-
-    * `parsed` is the list of parsed switches (same as in `parse_head/2`)
-    * `rest` is the list of arguments (same as in `parse_head/2`)
-
-  ## Examples
-
-      iex> OptionParser.parse_head!(["--source", "lib", "path/to/file", "--verbose"],
-      ...>                         switches: [source: :string, verbose: :boolean])
-      {[source: "lib"], ["path/to/file", "--verbose"]}
-
-      iex> OptionParser.parse_head!(["--number", "lib", "test/enum_test.exs", "--verbose"],
-      ...>                          strict: [number: :integer])
-      ** (OptionParser.ParseError) 1 error found!
-      --number : Expected type integer, got "lib"
-
-      iex> OptionParser.parse_head!(["--verbose", "--source", "lib", "test/enum_test.exs", "--unlock"],
-      ...>                          strict: [verbose: :integer, source: :integer])
-      ** (OptionParser.ParseError) 2 errors found!
-      --verbose : Missing argument of type integer
-      --source : Expected type integer, got "lib"
-  """
-  @spec parse_head!(argv, options) :: {parsed, argv} | no_return
-  def parse_head!(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    case parse_head(argv, opts) do
-      {parsed, args, []} -> {parsed, args}
-      {_, _, errors} -> raise ParseError, format_errors(errors, opts)
-    end
-  end
-
-  defp do_parse([], _config, opts, args, invalid, _all?) do
-    {Enum.reverse(opts), Enum.reverse(args), Enum.reverse(invalid)}
-  end
-
-  defp do_parse(argv, %{switches: switches} = config, opts, args, invalid, all?) do
-    case next_with_config(argv, config) do
-      {:ok, option, value, rest} ->
-        # the option exists and it was successfully parsed
-        kinds = List.wrap Keyword.get(switches, option)
-        new_opts = store_option(opts, option, value, kinds)
-        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?)
-
-      {:undefined, option, _value, rest} ->
-        # the option does not exist (for strict cases)
-        do_parse(rest, config, opts, args, [{option, nil} | invalid], all?)
-
-      {:error, ["--" | rest]} ->
-        {Enum.reverse(opts), Enum.reverse(args, rest), Enum.reverse(invalid)}
-
-      {:error, [arg | rest] = remaining_args} ->
-        # there is no option
-        if all? do
-          do_parse(rest, config, opts, [arg | args], invalid, all?)
-        else
-          {Enum.reverse(opts), Enum.reverse(args, remaining_args), Enum.reverse(invalid)}
-        end
-    end
-  end
-
-  @doc """
-  Low-level function that parses one option.
-
-  It accepts the same options as `parse/2` and `parse_head/2`
-  as both functions are built on top of this function. This function
-  may return:
-
-    * `{:ok, key, value, rest}` - the option `key` with `value` was
-      successfully parsed
-
-    * `{:invalid, key, value, rest}` - the option `key` is invalid with `value`
-      (returned when the value cannot be parsed according to the switch type)
-
-    * `{:undefined, key, value, rest}` - the option `key` is undefined
-      (returned in strict mode when the switch is unknown)
-
-    * `{:error, rest}` - there are no switches at the head of the given `argv`
-
-  """
-  @spec next(argv, options) ::
-        {:ok, key :: atom, value :: term, argv} |
-        {:invalid, String.t, String.t | nil, argv} |
-        {:undefined, String.t, String.t | nil, argv} |
-        {:error, argv}
-
-  def next(argv, opts \\ []) when is_list(argv) and is_list(opts) do
-    next_with_config(argv, build_config(opts))
-  end
-
-  defp next_with_config([], _config) do
-    {:error, []}
-  end
-
-  defp next_with_config(["--" | _] = argv, _config) do
-    {:error, argv}
-  end
-
-  defp next_with_config(["-" | _] = argv, _config) do
-    {:error, argv}
-  end
-
-  defp next_with_config(["- " <> _ | _] = argv, _config) do
-    {:error, argv}
-  end
-
-  # Handles --foo or --foo=bar
-  defp next_with_config(["--" <> option | rest], config) do
-    {option, value} = split_option(option)
-    tagged = tag_option(option, config)
-    next_tagged(tagged, value, "--" <> option, rest, config)
-  end
-
-  # Handles -a, -abc, -abc=something
-  defp next_with_config(["-" <> option | rest] = argv, config) do
-    %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?} = config
-    {option, value} = split_option(option)
-    original = "-" <> option
-
-    cond do
-      is_nil(value) and negative_number?(original) ->
-        {:error, argv}
-      String.contains?(option, ["-", "_"]) ->
-        {:undefined, original, value, rest}
-      String.length(option) > 1 ->
-        key = get_option_key(option, allow_nonexistent_atoms?)
-        option_key = aliases[key]
-        if key && option_key do
-          IO.warn "multi-letter aliases are deprecated, got: #{inspect(key)}"
-          next_tagged({:default, option_key}, value, original, rest, config)
-        else
-          next_with_config(expand_multiletter_alias(option, value) ++ rest, config)
-        end
-      true ->
-        # We have a regular one-letter alias here
-        tagged = tag_oneletter_alias(option, config)
-        next_tagged(tagged, value, original, rest, config)
-    end
-  end
-
-  defp next_with_config(argv, _config) do
-    {:error, argv}
-  end
-
-  defp next_tagged(tagged, value, original, rest, %{switches: switches, strict?: strict?}) do
-    if strict? and not option_defined?(tagged, switches) do
-      {:undefined, original, value, rest}
-    else
-      {option, kinds, value} = normalize_option(tagged, value, switches)
-      {value, kinds, rest} = normalize_value(value, kinds, rest, strict?)
-      case validate_option(value, kinds) do
-        {:ok, new_value} -> {:ok, option, new_value, rest}
-        :invalid         -> {:invalid, original, value, rest}
-      end
-    end
-  end
-
-  @doc """
-  Receives a key-value enumerable and converts it to `t:argv/0`.
-
-  Keys must be atoms. Keys with `nil` value are discarded,
-  boolean values are converted to `--key` or `--no-key`
-  (if the value is `true` or `false`, respectively),
-  and all other values are converted using `Kernel.to_string/1`.
-
-  It is advised to pass to `to_argv/2` the same set of `options`
-  given to `parse/2`. Some switches can only be reconstructed
-  correctly with the `switches` information in hand.
-
-  ## Examples
-
-      iex>  OptionParser.to_argv([foo_bar: "baz"])
-      ["--foo-bar", "baz"]
-      iex>  OptionParser.to_argv([bool: true, bool: false, discarded: nil])
-      ["--bool", "--no-bool"]
-
-  Some switches will output different values based on the switches
-  flag:
-
-      iex> OptionParser.to_argv([number: 2], switches: [])
-      ["--number", "2"]
-      iex> OptionParser.to_argv([number: 2], switches: [number: :count])
-      ["--number", "--number"]
-
-  """
-  @spec to_argv(Enumerable.t, options) :: argv
-  def to_argv(enum, opts \\ []) do
-    switches = Keyword.get(opts, :switches, [])
-    Enum.flat_map(enum, fn
-      {_key, nil}  -> []
-      {key, true}  -> [to_switch(key)]
-      {key, false} -> [to_switch(key, "--no-")]
-      {key, value} -> to_argv(key, value, switches)
-    end)
-  end
-
-  defp to_argv(key, value, switches) do
-    if switches[key] == :count do
-      List.duplicate(to_switch(key), value)
-    else
-      [to_switch(key), to_string(value)]
-    end
-  end
-
-  defp to_switch(key, prefix \\ "--") when is_atom(key) do
-    prefix <> String.replace(Atom.to_string(key), "_", "-")
-  end
-
-  @doc ~S"""
-  Splits a string into `t:argv/0` chunks.
-
-  This function splits the given `string` into a list of strings in a similar
-  way to many shells.
-
-  ## Examples
-
-      iex> OptionParser.split("foo bar")
-      ["foo", "bar"]
-
-      iex> OptionParser.split("foo \"bar baz\"")
-      ["foo", "bar baz"]
-
-  """
-  @spec split(String.t) :: argv
-  def split(string) when is_binary(string) do
-    do_split(String.trim_leading(string, " "), "", [], nil)
-  end
-
-  # If we have an escaped quote, simply remove the escape
-  defp do_split(<<?\\, quote, t::binary>>, buffer, acc, quote),
-    do: do_split(t, <<buffer::binary, quote>>, acc, quote)
-
-  # If we have a quote and we were not in a quote, start one
-  defp do_split(<<quote, t::binary>>, buffer, acc, nil) when quote in [?", ?'],
-    do: do_split(t, buffer, acc, quote)
-
-  # If we have a quote and we were inside it, close it
-  defp do_split(<<quote, t::binary>>, buffer, acc, quote),
-    do: do_split(t, buffer, acc, nil)
-
-  # If we have an escaped quote/space, simply remove the escape as long as we are not inside a quote
-  defp do_split(<<?\\, h, t::binary>>, buffer, acc, nil) when h in [?\s, ?', ?"],
-    do: do_split(t, <<buffer::binary, h>>, acc, nil)
-
-  # 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)
-
-  # All other characters are moved to buffer
-  defp do_split(<<h, t::binary>>, buffer, acc, quote) do
-    do_split(t, <<buffer::binary, h>>, acc, quote)
-  end
-
-  # Finish the string expecting a nil marker
-  defp do_split(<<>>, "", acc, nil),
-    do: Enum.reverse(acc)
-
-  defp do_split(<<>>, buffer, acc, nil),
-    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
-
-  ## Helpers
-
-  defp build_config(opts) do
-    {switches, strict?} = cond do
-      opts[:switches] && opts[:strict] ->
-        raise ArgumentError, ":switches and :strict cannot be given together"
-      switches = opts[:switches] ->
-        {switches, false}
-      strict = opts[:strict] ->
-        {strict, true}
-      true ->
-        {[], false}
-    end
-
-    %{
-      aliases: opts[:aliases] || [],
-      allow_nonexistent_atoms?: opts[:allow_nonexistent_atoms] || false,
-      strict?: strict?,
-      switches: switches
-    }
-  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
-
-    if invalid? do
-      :invalid
-    else
-      {:ok, value}
-    end
-  end
-
-  defp 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]
-      true ->
-        [{option, value} | Keyword.delete(dict, option)]
-    end
-  end
-
-  defp tag_option("no-" <> option = original, %{switches: switches, allow_nonexistent_atoms?: allow_nonexistent_atoms?}) do
-    cond do
-      (negated = get_option_key(option, allow_nonexistent_atoms?)) && :boolean in List.wrap(switches[negated]) ->
-        {:negated, negated}
-      option_key = get_option_key(original, allow_nonexistent_atoms?) ->
-        {:default, option_key}
-      true ->
-        :unknown
-    end
-  end
-
-  defp tag_option(option, %{allow_nonexistent_atoms?: allow_nonexistent_atoms?}) do
-    if option_key = get_option_key(option, allow_nonexistent_atoms?) do
-      {:default, option_key}
-    else
-      :unknown
-    end
-  end
-
-  defp tag_oneletter_alias(alias, %{aliases: aliases, allow_nonexistent_atoms?: allow_nonexistent_atoms?}) when is_binary(alias) do
-    if option_key = aliases[to_existing_key(alias, allow_nonexistent_atoms?)] do
-      {:default, option_key}
-    else
-      :unknown
-    end
-  end
-
-  defp expand_multiletter_alias(letters, value) when is_binary(letters) do
-    {last, expanded} =
-      letters
-      |> String.codepoints()
-      |> Enum.map(&("-" <> &1))
-      |> List.pop_at(-1)
-    expanded ++ [last <> if(value, do: "=" <> value, else: "")]
-  end
-
-  defp option_defined?(:unknown, _switches) do
-    false
-  end
-
-  defp option_defined?({:negated, option}, switches) do
-    Keyword.has_key?(switches, option)
-  end
-
-  defp option_defined?({:default, option}, switches) do
-    Keyword.has_key?(switches, option)
-  end
-
-  defp normalize_option(:unknown, value, _switches) do
-    {nil, [:invalid], value}
-  end
-
-  defp normalize_option({:negated, option}, value, switches) do
-    if value do
-      {option, [:invalid], value}
-    else
-      {option, List.wrap(switches[option]), false}
-    end
-  end
-
-  defp normalize_option({:default, option}, value, switches) do
-    {option, List.wrap(switches[option]), value}
-  end
-
-  defp normalize_value(nil, kinds, t, strict?) do
-    cond do
-      :boolean in kinds ->
-        {true, kinds, t}
-      :count in kinds ->
-        {1, kinds, t}
-      value_in_tail?(t) ->
-        [h | t] = t
-        {h, kinds, t}
-      kinds == [] and strict? ->
-        {nil, kinds, t}
-      kinds == [] ->
-        {true, kinds, t}
-      true ->
-        {nil, [:invalid], t}
-    end
-  end
-
-  defp normalize_value(value, kinds, t, _strict?) 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 split_option(option) do
-    case :binary.split(option, "=") do
-      [h]    -> {h, nil}
-      [h, t] -> {h, t}
-    end
-  end
-
-  defp to_underscore(option),
-    do: to_underscore(option, <<>>)
-  defp to_underscore("_" <> _rest, _acc),
-    do: nil
-  defp to_underscore("-" <> rest, acc),
-    do: to_underscore(rest, acc <> "_")
-  defp to_underscore(<<c>> <> rest, acc),
-    do: to_underscore(rest, <<acc::binary, c>>)
-  defp to_underscore(<<>>, acc),
-    do: acc
-
-  defp get_option_key(option, allow_nonexistent_atoms?) do
-    if string = to_underscore(option) do
-      to_existing_key(string, allow_nonexistent_atoms?)
-    end
-  end
-
-  defp to_existing_key(option, true),
-    do: String.to_atom(option)
-  defp to_existing_key(option, false) do
-    try do
-      String.to_existing_atom(option)
-    rescue
-      ArgumentError -> nil
-    end
-  end
-
-  defp negative_number?(arg) do
-    match?({_, ""}, Float.parse(arg))
-  end
-
-  defp format_errors([_ | _] = errors, opts) do
-    types = opts[:switches] || opts[:strict]
-    error_count = length(errors)
-    error = if error_count == 1, do: "error", else: "errors"
-    "#{error_count} #{error} found!\n" <>
-      Enum.map_join(errors, "\n", &format_error(&1, opts, types))
-  end
-
-  defp format_error({option, nil}, opts, types) do
-    if type = get_type(option, opts, types) do
-      "#{option} : Missing argument of type #{type}"
-    else
-      "#{option} : Unknown option"
-    end
-  end
-
-  defp format_error({option, value}, opts, types) do
-    type = get_type(option, opts, types)
-    "#{option} : Expected type #{type}, got #{inspect value}"
-  end
-
-  defp get_type(option, opts, types) do
-    allow_nonexistent_atoms? = opts[:allow_nonexistent_atoms] || false
-    key = option |> String.trim_leading("-") |> get_option_key(allow_nonexistent_atoms?)
-
-    if option_key = opts[:aliases][key] do
-      types[option_key]
-    else
-      types[key]
-    end
-  end
-end

lib/elixir/lib/path.ex

@@ -1,687 +0,0 @@
-defmodule Path do
-  @moduledoc """
-  This module provides conveniences for manipulating or
-  retrieving file system paths.
-
-  The functions in this module may receive a chardata 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`).
-  """
-
-  @type t :: :unicode.chardata()
-
-  @doc """
-  Converts the given path to an absolute one. Unlike
-  `expand/1`, no attempt is made to resolve `..`, `.` or `~`.
-
-  ## Examples
-
-  ### Unix
-
-      Path.absname("foo")
-      #=> "/usr/local/foo"
-
-      Path.absname("../x")
-      #=> "/usr/local/../x"
-
-  ### Windows
-
-      Path.absname("foo").
-      #=> "D:/usr/local/foo"
-      Path.absname("../x").
-      #=> "D:/usr/local/../x"
-
-  """
-  @spec absname(t) :: binary
-  def absname(path) do
-    absname(path, System.cwd!)
-  end
-
-  @doc """
-  Builds a path from `relative_to` to `path`.
-
-  If `path` is already an absolute path, `relative_to` is ignored. See also
-  `relative_to/2`.
-
-  Unlike `expand/2`, no attempt is made to
-  resolve `..`, `.` or `~`.
-
-  ## Examples
-
-      iex> Path.absname("foo", "bar")
-      "bar/foo"
-
-      iex> Path.absname("../x", "bar")
-      "bar/../x"
-
-  """
-  @spec absname(t, t) :: binary
-  def absname(path, relative_to) do
-    path = IO.chardata_to_string(path)
-    case type(path) do
-      :relative -> absname_join(relative_to, path)
-      :absolute -> absname_join([path])
-      :volumerelative ->
-        relative_to = IO.chardata_to_string(relative_to)
-        absname_vr(split(path), split(relative_to), relative_to)
-    end
-  end
-
-  # Absolute path on current drive
-  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),
-    do: absname(absname_join(rest), relative)
-
-  # Relative to current directory on another drive.
-  defp absname_vr([<<x, ?:>> | name], _, _relative) do
-    cwd =
-      case :file.get_cwd([x, ?:]) do
-        {:ok, dir}  -> IO.chardata_to_string(dir)
-        {:error, _} -> <<x, ?:, ?/>>
-      end
-    absname(absname_join(name), cwd)
-  end
-
-  # Joins a list
-  defp absname_join([name1, name2 | rest]), do:
-    absname_join([absname_join(name1, name2) | rest])
-  defp absname_join([name]), do:
-    do_absname_join(IO.chardata_to_string(name), <<>>, [], major_os_type())
-
-  # Joins two paths
-  defp absname_join(left, right),
-    do: do_absname_join(IO.chardata_to_string(left), relative(right), [], major_os_type())
-
-  defp do_absname_join(<<uc_letter, ?:, rest::binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
-    do_absname_join(rest, relativename, [?:, uc_letter + ?a - ?A], :win32)
-  defp do_absname_join(<<?\\, rest::binary>>, relativename, result, :win32), do:
-    do_absname_join(<<?/, rest::binary>>, relativename, result, :win32)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?., ?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
-  defp do_absname_join(<<?/, rest::binary>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(rest, relativename, [?/ | result], os_type)
-  defp do_absname_join(<<>>, <<>>, result, os_type), do:
-    IO.iodata_to_binary(reverse_maybe_remove_dir_sep(result, os_type))
-  defp do_absname_join(<<>>, relativename, [?: | rest], :win32), do:
-    do_absname_join(relativename, <<>>, [?: | rest], :win32)
-  defp do_absname_join(<<>>, relativename, [?/ | result], os_type), do:
-    do_absname_join(relativename, <<>>, [?/ | result], os_type)
-  defp do_absname_join(<<>>, relativename, result, os_type), do:
-    do_absname_join(relativename, <<>>, [?/ | result], os_type)
-  defp do_absname_join(<<char, rest::binary>>, relativename, result, os_type), do:
-    do_absname_join(rest, relativename, [char | result], os_type)
-
-  defp reverse_maybe_remove_dir_sep([?/, ?:, letter], :win32), do:
-    [letter, ?:, ?/]
-  defp reverse_maybe_remove_dir_sep([?/], _), do:
-    [?/]
-  defp reverse_maybe_remove_dir_sep([?/ | name], _), do:
-    :lists.reverse(name)
-  defp reverse_maybe_remove_dir_sep(name, _), do:
-    :lists.reverse(name)
-
-  @doc """
-  Converts the path to an absolute one and expands
-  any `.` and `..` characters and a leading `~`.
-
-  ## Examples
-
-      Path.expand("/foo/bar/../bar")
-      #=> "/foo/bar"
-
-  """
-  @spec expand(t) :: binary
-  def expand(path) do
-    expand_dot absname(expand_home(path), System.cwd!)
-  end
-
-  @doc """
-  Expands the path relative to the path given as the second argument
-  expanding any `.` and `..` characters.
-
-  If the path is already an absolute path, `relative_to` is ignored.
-
-  Note that this function treats a `path` with a leading `~` as
-  an absolute one.
-
-  The second argument is first expanded to an absolute path.
-
-  ## Examples
-
-      # Assuming that the absolute path to baz is /quux/baz
-      Path.expand("foo/bar/../bar", "baz")
-      #=> "/quux/baz/foo/bar"
-
-      Path.expand("foo/bar/../bar", "/baz")
-      "/baz/foo/bar"
-      Path.expand("/foo/bar/../bar", "/baz")
-      "/foo/bar"
-
-  """
-  @spec expand(t, t) :: binary
-  def expand(path, relative_to) do
-    expand_dot absname(absname(expand_home(path), expand_home(relative_to)), System.cwd!)
-  end
-
-  @doc """
-  Returns the path type.
-
-  ## Examples
-
-  ### Unix
-
-      Path.type("/")                #=> :absolute
-      Path.type("/usr/local/bin")   #=> :absolute
-      Path.type("usr/local/bin")    #=> :relative
-      Path.type("../usr/local/bin") #=> :relative
-      Path.type("~/file")           #=> :relative
-
-  ### Windows
-
-      Path.type("D:/usr/local/bin") #=> :absolute
-      Path.type("usr/local/bin")    #=> :relative
-      Path.type("D:bar.ex")         #=> :volumerelative
-      Path.type("/bar/foo.ex")      #=> :volumerelative
-
-  """
-  @spec type(t) :: :absolute | :relative | :volumerelative
-  def type(name)
-      when is_list(name)
-      when is_binary(name) do
-    pathtype(name, major_os_type()) |> elem(0)
-  end
-
-  @doc """
-  Forces the path to be a relative path.
-
-  ## Examples
-
-  ### Unix
-
-      Path.relative("/usr/local/bin")   #=> "usr/local/bin"
-      Path.relative("usr/local/bin")    #=> "usr/local/bin"
-      Path.relative("../usr/local/bin") #=> "../usr/local/bin"
-
-  ### Windows
-
-      Path.relative("D:/usr/local/bin") #=> "usr/local/bin"
-      Path.relative("usr/local/bin")    #=> "usr/local/bin"
-      Path.relative("D:bar.ex")         #=> "bar.ex"
-      Path.relative("/bar/foo.ex")      #=> "bar/foo.ex"
-
-  """
-  @spec relative(t) :: binary
-  def relative(name) do
-    relative(name, major_os_type())
-  end
-
-  defp relative(name, os_type) do
-    pathtype(name, os_type)
-    |> elem(1)
-    |> IO.chardata_to_string
-  end
-
-  defp pathtype(name, os_type) do
-    case os_type do
-      :win32 -> win32_pathtype(name)
-      _      -> unix_pathtype(name)
-    end
-  end
-
-  defp unix_pathtype(path) when path in ["/", '/'],
-    do: {:absolute, "."}
-  defp unix_pathtype(<<?/, relative::binary>>),
-    do: {:absolute, relative}
-  defp unix_pathtype([?/ | relative]),
-    do: {:absolute, relative}
-  defp unix_pathtype([list | rest]) when is_list(list),
-    do: unix_pathtype(list ++ rest)
-  defp unix_pathtype(relative),
-    do: {:relative, relative}
-
-  @slash [?/, ?\\]
-
-  defp win32_pathtype([list | rest]) when is_list(list),
-    do: win32_pathtype(list ++ rest)
-  defp win32_pathtype([char, list | rest]) when is_list(list),
-    do: win32_pathtype([char | list ++ rest])
-  defp win32_pathtype(<<c1, c2, relative::binary>>) when c1 in @slash and c2 in @slash,
-    do: {:absolute, relative}
-  defp win32_pathtype(<<char, relative::binary>>) when char in @slash,
-    do: {:volumerelative, relative}
-  defp win32_pathtype(<<_letter, ?:, char, relative::binary>>) when char in @slash,
-    do: {:absolute, relative}
-  defp win32_pathtype(<<_letter, ?:, relative::binary>>),
-    do: {:volumerelative, relative}
-
-  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash,
-    do: {:absolute, relative}
-  defp win32_pathtype([char | relative]) when char in @slash,
-    do: {:volumerelative, relative}
-  defp win32_pathtype([c1, c2, list | rest]) when is_list(list),
-    do: win32_pathtype([c1, c2 | list ++ rest])
-  defp win32_pathtype([_letter, ?:, char | relative]) when char in @slash,
-    do: {:absolute, relative}
-  defp win32_pathtype([_letter, ?: | relative]),
-    do: {:volumerelative, relative}
-  defp win32_pathtype(relative),
-    do: {:relative, relative}
-
-  @doc """
-  Returns the given `path` relative to the given `from` path.
-
-  In other words, this function tries to strip the `from` prefix from `path`.
-
-  This function does not query the file system, so it assumes
-  no symlinks between the paths.
-
-  In case a direct relative path cannot be found, it returns
-  the original path.
-
-  ## Examples
-
-      iex> Path.relative_to("/usr/local/foo", "/usr/local")
-      "foo"
-
-      iex> Path.relative_to("/usr/local/foo", "/")
-      "usr/local/foo"
-
-      iex> Path.relative_to("/usr/local/foo", "/etc")
-      "/usr/local/foo"
-
-  """
-  @spec relative_to(t, t) :: binary
-  def relative_to(path, from) do
-    path = IO.chardata_to_string(path)
-    relative_to(split(path), split(from), path)
-  end
-
-  defp relative_to([h | t1], [h | t2], original) do
-    relative_to(t1, t2, original)
-  end
-
-  defp relative_to([_ | _] = l1, [], _original) do
-    join(l1)
-  end
-
-  defp relative_to(_, _, original) do
-    original
-  end
-
-  @doc """
-  Convenience to get the path relative to the current working
-  directory.
-
-  If, for some reason, the current working directory
-  cannot be retrieved, this function returns the given `path`.
-  """
-  @spec relative_to_cwd(t) :: binary
-  def relative_to_cwd(path) do
-    case :file.get_cwd do
-      {:ok, base} -> relative_to(path, IO.chardata_to_string(base))
-      _ -> path
-    end
-  end
-
-  @doc """
-  Returns the last component of the path or the path
-  itself if it does not contain any directory separators.
-
-  ## Examples
-
-      iex> Path.basename("foo")
-      "foo"
-
-      iex> Path.basename("foo/bar")
-      "bar"
-
-      iex> Path.basename("/")
-      ""
-
-  """
-  @spec basename(t) :: binary
-  def basename(path) do
-    :filename.basename(IO.chardata_to_string(path))
-  end
-
-  @doc """
-  Returns the last component of `path` with the `extension`
-  stripped.
-
-  This function should be used to remove a specific
-  extension which may or may not be there.
-
-  ## Examples
-
-      iex> Path.basename("~/foo/bar.ex", ".ex")
-      "bar"
-
-      iex> Path.basename("~/foo/bar.exs", ".ex")
-      "bar.exs"
-
-      iex> Path.basename("~/foo/bar.old.ex", ".ex")
-      "bar.old"
-
-  """
-  @spec basename(t, t) :: binary
-  def basename(path, extension) do
-    :filename.basename(IO.chardata_to_string(path), IO.chardata_to_string(extension))
-  end
-
-  @doc """
-  Returns the directory component of `path`.
-
-  ## Examples
-
-      iex> Path.dirname("/foo/bar.ex")
-      "/foo"
-
-      iex> Path.dirname("/foo/bar/baz.ex")
-      "/foo/bar"
-
-      iex> Path.dirname("/foo/bar/")
-      "/foo/bar"
-
-  """
-  @spec dirname(t) :: binary
-  def dirname(path) do
-    :filename.dirname(IO.chardata_to_string(path))
-  end
-
-  @doc """
-  Returns the extension of the last component of `path`.
-
-  ## Examples
-
-      iex> Path.extname("foo.erl")
-      ".erl"
-
-      iex> Path.extname("~/foo/bar")
-      ""
-
-  """
-  @spec extname(t) :: binary
-  def extname(path) do
-    :filename.extension(IO.chardata_to_string(path))
-  end
-
-  @doc """
-  Returns the `path` with the `extension` stripped.
-
-  ## Examples
-
-      iex> Path.rootname("/foo/bar")
-      "/foo/bar"
-
-      iex> Path.rootname("/foo/bar.ex")
-      "/foo/bar"
-
-  """
-  @spec rootname(t) :: binary
-  def rootname(path) do
-    :filename.rootname(IO.chardata_to_string(path))
-  end
-
-  @doc """
-  Returns the `path` with the `extension` stripped.
-
-  This function should be used to remove a specific extension which may
-  or may not be there.
-
-  ## Examples
-
-      iex> Path.rootname("/foo/bar.erl", ".erl")
-      "/foo/bar"
-
-      iex> Path.rootname("/foo/bar.erl", ".ex")
-      "/foo/bar.erl"
-
-  """
-  @spec rootname(t, t) :: binary
-  def rootname(path, extension) do
-    :filename.rootname(IO.chardata_to_string(path), IO.chardata_to_string(extension))
-  end
-
-  @doc """
-  Joins a list of paths.
-
-  This function should be used to convert a list of paths to a path.
-  Note that any trailing slash is removed when joining.
-
-  ## Examples
-
-      iex> Path.join(["~", "foo"])
-      "~/foo"
-
-      iex> Path.join(["foo"])
-      "foo"
-
-      iex> Path.join(["/", "foo", "bar/"])
-      "/foo/bar"
-
-  """
-  @spec join(nonempty_list(t)) :: binary
-  def join([name1, name2 | rest]), do:
-    join([join(name1, name2) | rest])
-  def join([name]), do:
-    IO.chardata_to_string(name)
-
-  @doc """
-  Joins two paths.
-
-  The right path will always be expanded to its relative format
-  and any trailing slash will be removed when joining.
-
-  ## Examples
-
-      iex> Path.join("foo", "bar")
-      "foo/bar"
-
-      iex> Path.join("/foo", "/bar/")
-      "/foo/bar"
-
-  """
-  @spec join(t, t) :: binary
-  def join(left, right) do
-    left    = IO.chardata_to_string(left)
-    os_type = major_os_type()
-    do_join(left, right, os_type) |> remove_dir_sep(os_type)
-  end
-
-  defp do_join("", right, os_type),   do: relative(right, os_type)
-  defp do_join("/", right, os_type),  do: "/" <> relative(right, os_type)
-  defp do_join(left, right, os_type), do: remove_dir_sep(left, os_type) <> "/" <> relative(right, os_type)
-
-  defp remove_dir_sep("", _os_type), do: ""
-  defp remove_dir_sep("/", _os_type), do: "/"
-  defp remove_dir_sep(bin, os_type) do
-    last = :binary.last(bin)
-    if last == ?/ or (last == ?\\ and os_type == :win32) do
-      binary_part(bin, 0, byte_size(bin) - 1)
-    else
-      bin
-    end
-  end
-
-  @doc ~S"""
-  Splits the path into a list at the path separator.
-
-  If an empty string is given, returns an empty list.
-
-  On Windows, path is split on both "\" and "/" separators
-  and the driver letter, if there is one, is always returned
-  in lowercase.
-
-  ## Examples
-
-      iex> Path.split("")
-      []
-
-      iex> Path.split("foo")
-      ["foo"]
-
-      iex> Path.split("/foo/bar")
-      ["/", "foo", "bar"]
-
-  """
-  @spec split(t) :: [binary]
-
-  # Work around a bug in Erlang on UNIX
-  def split(""), do: []
-
-  def split(path) do
-    :filename.split(IO.chardata_to_string(path))
-  end
-
-  defmodule Wildcard do
-    @moduledoc false
-
-    def read_link_info(file) do
-      call({:read_link_info, file})
-    end
-
-    def list_dir(dir) do
-      case call({:list_dir, dir}) do
-        {:ok, files} ->
-          {:ok, for(file <- files, hd(file) != ?., do: file)}
-        other ->
-          other
-      end
-    end
-
-    @compile {:inline, call: 1}
-
-    defp call(tuple) do
-      x = :erlang.dt_spread_tag(true)
-      y = :gen_server.call(:file_server_2, tuple)
-      :erlang.dt_restore_tag(x)
-      y
-    end
-  end
-
-  @doc """
-  Traverses paths according to the given `glob` expression and returns a
-  list of matches.
-
-  The wildcard looks like an ordinary path, except that certain
-  "wildcard characters" are interpreted in a special way. The
-  following characters are special:
-
-    * `?` - matches one character
-
-    * `*` - matches any number of characters up to the end of the filename, the
-      next dot, or the next slash
-
-    * `**` - two adjacent `*`'s used as a single pattern will match all
-      files and zero or more directories and subdirectories
-
-    * `[char1,char2,...]` - matches any of the characters listed; two
-      characters separated by a hyphen will match a range of characters.
-      Do not add spaces before and after the comma as it would then match
-      paths containing the space character itself.
-
-    * `{item1,item2,...}` - matches one of the alternatives
-      Do not add spaces before and after the comma as it would then match
-      paths containing the space character itself.
-
-  Other characters represent themselves. Only paths that have
-  exactly the same character in the same position will match. Note
-  that matching is case-sensitive: `"a"` will not match `"A"`.
-
-  By default, the patterns `*` and `?` do not match files starting
-  with a dot `.` unless `match_dot: true` is given in `opts`.
-
-  ## Examples
-
-  Imagine you have a directory called `projects` with three Elixir projects
-  inside of it: `elixir`, `ex_doc`, and `plug`. You can find all `.beam` files
-  inside the `ebin` directory of each project as follows:
-
-      Path.wildcard("projects/*/ebin/**/*.beam")
-
-  If you want to search for both `.beam` and `.app` files, you could do:
-
-      Path.wildcard("projects/*/ebin/**/*.{beam,app}")
-
-  """
-  @spec wildcard(t, keyword) :: [binary]
-  def wildcard(glob, opts \\ []) do
-    mod = if Keyword.get(opts, :match_dot), do: :file, else: Path.Wildcard
-    glob
-    |> chardata_to_list!()
-    |> :filelib.wildcard(mod)
-    |> Enum.map(&IO.chardata_to_string/1)
-  end
-
-  defp chardata_to_list!(chardata) do
-    case :unicode.characters_to_list(chardata) do
-      result when is_list(result) ->
-        if 0 in result do
-          raise ArgumentError, "cannot execute Path.wildcard/2 for path with null byte, got: #{inspect chardata}"
-        else
-          result
-        end
-
-      {:error, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :invalid
-
-      {:incomplete, encoded, rest} ->
-        raise UnicodeConversionError, encoded: encoded, rest: rest, kind: :incomplete
-    end
-  end
-
-  defp expand_home(type) do
-    case IO.chardata_to_string(type) do
-      "~" <> rest -> resolve_home(rest)
-      rest        -> rest
-    end
-  end
-
-  defp resolve_home(""), do: System.user_home!
-
-  defp resolve_home(rest) do
-    case {rest, major_os_type()} do
-      {"\\" <> _, :win32} ->
-        System.user_home! <> rest
-      {"/" <> _, _} ->
-        System.user_home! <> rest
-      _ -> rest
-    end
-  end
-
-  # expand_dot the given path by expanding "..", "." and "~".
-
-  defp expand_dot(<<"/", rest::binary>>),
-    do: "/" <> do_expand_dot(rest)
-  defp expand_dot(<<letter, ":/", rest::binary>>) when letter in ?a..?z,
-    do: <<letter, ":/">> <> do_expand_dot(rest)
-  defp expand_dot(path),
-    do: do_expand_dot(path)
-
-  defp do_expand_dot(path),
-    do: do_expand_dot(:binary.split(path, "/", [:global]), [])
-
-  defp do_expand_dot([".." | t], [_, _ | acc]),
-    do: do_expand_dot(t, acc)
-  defp do_expand_dot([".." | t], []),
-    do: do_expand_dot(t, [])
-  defp do_expand_dot(["." | t], acc),
-    do: do_expand_dot(t, acc)
-  defp do_expand_dot([h | t], acc),
-    do: do_expand_dot(t, ["/", h | acc])
-  defp do_expand_dot([], []),
-    do: ""
-  defp do_expand_dot([], ["/" | acc]),
-    do: IO.iodata_to_binary(:lists.reverse(acc))
-
-  defp major_os_type do
-    :os.type |> elem(0)
-  end
-end

lib/elixir/lib/port.ex

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

lib/elixir/lib/process.ex

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

lib/elixir/lib/protocol.ex

@@ -1,687 +0,0 @@
-defmodule Protocol do
-  @moduledoc """
-  Functions for working with protocols.
-  """
-
-  @doc """
-  Defines a new protocol function.
-
-  Protocols do not allow functions to be defined directly, instead, the
-  regular `Kernel.def/*` macros are replaced by this macro which
-  defines the protocol functions with the appropriate callbacks.
-  """
-  defmacro def(signature)
-
-  defmacro def({_, _, args}) when args == [] or is_atom(args) do
-    raise ArgumentError, "protocol functions expect at least one argument"
-  end
-
-  defmacro def({name, _, args}) when is_atom(name) and is_list(args) do
-    arity = length(args)
-
-    type_args = :lists.map(fn _ -> quote(do: term) end,
-                           :lists.seq(2, arity))
-    type_args = [quote(do: t) | type_args]
-
-    call_args = :lists.map(fn pos -> Macro.var(String.to_atom("var" <> Integer.to_string(pos)), __MODULE__) end,
-                           :lists.seq(2, arity))
-    call_args = [quote(do: term) | call_args]
-
-    quote do
-      name  = unquote(name)
-      arity = unquote(arity)
-
-      @functions [{name, arity} | @functions]
-
-      # Generate a fake definition with the user
-      # signature that will be used by docs
-      Kernel.def unquote(name)(unquote_splicing(args))
-
-      # Generate the actual implementation
-      Kernel.def unquote(name)(unquote_splicing(call_args)) do
-        impl_for!(term).unquote(name)(unquote_splicing(call_args))
-      end
-
-      # Convert the spec to callback if possible,
-      # otherwise generate a dummy callback
-      Protocol.__spec__?(__MODULE__, name, arity) ||
-        @callback unquote(name)(unquote_splicing(type_args)) :: term
-    end
-  end
-
-  defmacro def(_) do
-    raise ArgumentError, "invalid arguments for def inside defprotocol"
-  end
-
-  @doc """
-  Checks if the given module is loaded and is protocol.
-
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
-  """
-  @spec assert_protocol!(module) :: :ok | no_return
-  def assert_protocol!(module) do
-    assert_protocol!(module, "")
-  end
-
-  defp assert_protocol!(module, extra) do
-    case Code.ensure_compiled(module) do
-      {:module, ^module} -> :ok
-      _ -> raise ArgumentError, "#{inspect module} is not available" <> extra
-    end
-
-    try do
-      module.__protocol__(:module)
-    rescue
-      UndefinedFunctionError ->
-        raise ArgumentError, "#{inspect module} is not a protocol" <> extra
-    end
-
-    :ok
-  end
-
-  @doc """
-  Checks if the given module is loaded and is an implementation
-  of the given protocol.
-
-  Returns `:ok` if so, otherwise raises `ArgumentError`.
-  """
-  @spec assert_impl!(module, module) :: :ok | no_return
-  def assert_impl!(protocol, base) do
-    assert_impl!(protocol, base, "")
-  end
-
-  defp assert_impl!(protocol, base, extra) do
-    impl = Module.concat(protocol, base)
-
-    case Code.ensure_compiled(impl) do
-      {:module, ^impl} -> :ok
-      _ -> raise ArgumentError,
-             "#{inspect impl} is not available" <> extra
-    end
-
-    try do
-      impl.__impl__(:protocol)
-    rescue
-      UndefinedFunctionError ->
-        raise ArgumentError,
-          "#{inspect impl} is not an implementation of a protocol" <> extra
-    else
-      ^protocol ->
-        :ok
-      other ->
-        raise ArgumentError,
-          "expected #{inspect impl} to be an implementation of #{inspect protocol}, got: #{inspect other}" <> extra
-    end
-  end
-
-  @doc """
-  Derives the `protocol` for `module` with the given options.
-  """
-  defmacro derive(protocol, module, options \\ []) do
-    quote do
-      module = unquote(module)
-      Protocol.__derive__([{unquote(protocol), unquote(options)}], module, __ENV__)
-    end
-  end
-
-  ## Consolidation
-
-  @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
-  avoid extra conversion.
-
-  Does not load any of the protocols.
-
-  ## Examples
-
-      # Get Elixir's ebin and retrieve all protocols
-      iex> path = :code.lib_dir(:elixir, :ebin)
-      iex> mods = Protocol.extract_protocols([path])
-      iex> Enumerable in mods
-      true
-
-  """
-  @spec extract_protocols([charlist | String.t]) :: [atom]
-  def extract_protocols(paths) do
-    extract_matching_by_attribute paths, 'Elixir.',
-      fn module, attributes ->
-        case attributes[:protocol] do
-          [fallback_to_any: _] -> module
-          _ -> nil
-        end
-      end
-  end
-
-  @doc """
-  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
-  avoid extra conversion.
-
-  Does not load any of the implementations.
-
-  ## Examples
-
-      # Get Elixir's ebin and retrieve all protocols
-      iex> path = :code.lib_dir(:elixir, :ebin)
-      iex> mods = Protocol.extract_impls(Enumerable, [path])
-      iex> List in mods
-      true
-
-  """
-  @spec extract_impls(module, [charlist | String.t]) :: [atom]
-  def extract_impls(protocol, paths) when is_atom(protocol) do
-    prefix = Atom.to_charlist(protocol) ++ '.'
-    extract_matching_by_attribute paths, prefix, fn
-      _mod, attributes ->
-        case attributes[:protocol_impl] do
-          [protocol: ^protocol, for: for] -> for
-          _ -> nil
-        end
-    end
-  end
-
-  defp extract_matching_by_attribute(paths, prefix, callback) do
-    for path <- paths,
-       file <- list_dir(path),
-       mod = extract_from_file(path, file, prefix, callback),
-       do: mod
-  end
-
-  defp list_dir(path) when is_list(path) do
-    case :file.list_dir(path) do
-      {:ok, files} -> files
-      _ -> []
-    end
-  end
-
-  defp list_dir(path), do: list_dir(to_charlist(path))
-
-  defp extract_from_file(path, file, prefix, callback) do
-    if :lists.prefix(prefix, file) and :filename.extension(file) == '.beam' do
-      extract_from_beam(:filename.join(path, file), callback)
-    end
-  end
-
-  defp extract_from_beam(file, callback) do
-    case :beam_lib.chunks(file, [:attributes]) do
-      {:ok, {module, [attributes: attributes]}} ->
-        callback.(module, attributes)
-       _ ->
-         nil
-    end
-  end
-
-  @doc """
-  Returns `true` if the protocol was consolidated.
-  """
-  @spec consolidated?(module) :: boolean
-  def consolidated?(protocol) do
-    protocol.__protocol__(:consolidated?)
-  end
-
-  @doc """
-  Receives a protocol and a list of implementations and
-  consolidates the given protocol.
-
-  Consolidation happens by changing the protocol `impl_for`
-  in the abstract format to have fast lookup rules. Usually
-  the list of implementations to use during consolidation
-  are retrieved with the help of `extract_impls/2`.
-
-  It returns the updated version of the protocol bytecode.
-  A given bytecode or protocol implementation can be checked
-  to be consolidated or not by analyzing the protocol
-  attribute:
-
-      Protocol.consolidated?(Enumerable)
-
-  If the first element of the tuple is `true`, it means
-  the protocol was consolidated.
-
-  This function does not load the protocol at any point
-  nor loads the new bytecode for the compiled module.
-  However each implementation must be available and
-  it will be loaded.
-  """
-  @spec consolidate(module, [module]) ::
-    {:ok, binary} |
-    {:error, :not_a_protocol} |
-    {:error, :no_beam_info}
-  def consolidate(protocol, types) when is_atom(protocol) do
-    with {:ok, ast_info, chunks_info} <- beam_protocol(protocol),
-         {:ok, code} <- change_debug_info(ast_info, types),
-         do: compile(protocol, code, chunks_info)
-  end
-
-  defp beam_protocol(protocol) do
-    chunk_ids = [:abstract_code, :attributes, :compile_info, 'ExDc']
-    opts = [:allow_missing_chunks]
-    case :beam_lib.chunks(beam_file(protocol), chunk_ids, opts) do
-      {:ok, {^protocol, [{:abstract_code, {_raw, abstract_code}},
-                         {:attributes, attributes},
-                         {:compile_info, compile_info},
-                         {'ExDc', docs}]}} ->
-        case attributes[:protocol] do
-          [fallback_to_any: any] ->
-            {:ok, {protocol, any, abstract_code}, {compile_info, docs}}
-          _ ->
-            {:error, :not_a_protocol}
-        end
-      _ ->
-        {:error, :no_beam_info}
-    end
-  end
-
-  defp beam_file(module) when is_atom(module) do
-    case :code.which(module) do
-      atom when is_atom(atom) -> module
-      file -> file
-    end
-  end
-
-  # Change the debug information to the optimized
-  # impl_for/1 dispatch version.
-  defp change_debug_info({protocol, any, code}, types) do
-    types   = if any, do: types, else: List.delete(types, Any)
-    all     = [Any] ++ for {_guard, mod} <- __builtin__(), do: mod
-    structs = types -- all
-    case change_impl_for(code, protocol, types, structs, false, []) do
-      {:ok, ret} -> {:ok, ret}
-      other      -> other
-    end
-  end
-
-  defp change_impl_for([{:function, line, :__protocol__, 1, clauses} | tail], protocol, types, structs, _, acc) do
-    abstract_types = :erl_parse.abstract(:lists.usort(types))
-
-    clauses = :lists.map(fn
-      {:clause, l, [{:atom, _, :consolidated?}], [], [{:atom, _, _}]} ->
-        {:clause, l, [{:atom, 0, :consolidated?}], [], [{:atom, 0, true}]}
-      {:clause, l, [{:atom, _, :impls}], [], [{:atom, _, _}]} ->
-        {:clause, l, [{:atom, 0, :impls}], [], [{:tuple, 0, [{:atom, 0, :consolidated}, abstract_types]}]}
-      {:clause, _, _, _, _} = c ->
-        c
-    end, clauses)
-
-    change_impl_for(tail, protocol, types, structs, true,
-                    [{:function, line, :__protocol__, 1, clauses} | acc])
-  end
-
-  defp change_impl_for([{:function, line, :impl_for, 1, _} | tail], protocol, types, structs, protocol?, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any)
-
-    clauses = for {guard, mod} <- __builtin__(),
-                  mod in types,
-                  do: builtin_clause_for(mod, guard, protocol, line)
-
-    clauses = [struct_clause_for(line) | clauses] ++
-              [fallback_clause_for(fallback, protocol, line)]
-
-    change_impl_for(tail, protocol, types, structs, protocol?,
-                    [{:function, line, :impl_for, 1, clauses} | acc])
-  end
-
-  defp change_impl_for([{:function, line, :struct_impl_for, 1, _} | tail], protocol, types, structs, protocol?, acc) do
-    fallback = if Any in types, do: load_impl(protocol, Any)
-    clauses = for struct <- structs, do: each_struct_clause_for(struct, protocol, line)
-    clauses = clauses ++ [fallback_clause_for(fallback, protocol, line)]
-
-    change_impl_for(tail, protocol, types, structs, protocol?,
-                    [{:function, line, :struct_impl_for, 1, clauses} | acc])
-  end
-
-  defp change_impl_for([{:attribute, line, :spec, {{:__protocol__, 1}, funspecs}} | tail], protocol, types, structs, protocol?, acc) do
-    new_specs = for spec <- funspecs do
-      case spec do
-        {:type, line, :fun, [{:type, _, :product, [{:atom, _, :consolidated?}]}, _]} ->
-          {:type, line, :fun,
-           [{:type, line, :product, [{:atom, 0, :consolidated?}]},
-            {:atom, 0, true}]}
-        {:type, line, :fun, [{:type, _, :product, [{:atom, _, :impls}]}, _]} ->
-          {:type, line, :fun,
-           [{:type, line, :product, [{:atom, 0, :impls}]},
-            {:type, 0, :tuple,
-             [{:atom, 0, :consolidated},
-              {:type, 0, :list, [{:type, 0, :module, []}]}]}]}
-        other -> other
-      end
-    end
-    change_impl_for(tail, protocol, types, structs, protocol?, [{:attribute, line, :spec, {{:__protocol__, 1}, new_specs}} | acc])
-  end
-
-  defp change_impl_for([head | tail], protocol, info, types, protocol?, acc) do
-    change_impl_for(tail, protocol, info, types, protocol?, [head | acc])
-  end
-
-  defp change_impl_for([], _protocol, _info, _types, protocol?, acc) do
-    if protocol? do
-      {:ok, Enum.reverse(acc)}
-    else
-      {:error, :not_a_protocol}
-    end
-  end
-
-  defp builtin_clause_for(mod, guard, protocol, line) do
-    {:clause, line,
-      [{:var, line, :x}],
-      [[{:call, line,
-          {:remote, line, {:atom, line, :erlang}, {:atom, line, guard}},
-          [{:var, line, :x}],
-     }]],
-      [{:atom, line, load_impl(protocol, mod)}]}
-  end
-
-  defp struct_clause_for(line) do
-    {:clause, line,
-      [{:map, line, [
-        {:map_field_exact, line, {:atom, line, :__struct__}, {:var, line, :x}}
-      ]}],
-      [[{:call, line,
-          {:remote, line, {:atom, line, :erlang}, {:atom, line, :is_atom}},
-          [{:var, line, :x}],
-     }]],
-      [{:call, line,
-          {:atom, line, :struct_impl_for},
-          [{:var, line, :x}]}]}
-  end
-
-  defp each_struct_clause_for(struct, protocol, line) do
-    {:clause, line, [{:atom, line, struct}], [],
-      [{:atom, line, load_impl(protocol, struct)}]}
-  end
-
-  defp fallback_clause_for(value, _protocol, line) do
-    {:clause, line, [{:var, line, :_}], [],
-      [{:atom, line, value}]}
-  end
-
-  defp load_impl(protocol, for) do
-    Module.concat(protocol, for).__impl__(:target)
-  end
-
-  # Finally compile the module and emit its bytecode.
-  defp compile(protocol, code, {compile_info, docs}) do
-    opts = Keyword.take(compile_info, [:source])
-    opts = if Code.compiler_options[:debug_info], do: [:debug_info | opts], else: opts
-    {:ok, ^protocol, binary, _warnings} = :compile.forms(code, [:return | opts])
-    {:ok,
-      case docs do
-        :missing_chunk -> binary
-        _ -> :elixir_erl.add_beam_chunks(binary, [{"ExDc", docs}])
-      end}
-  end
-
-  ## Definition callbacks
-
-  @doc false
-  def __protocol__(name, [do: block]) do
-    quote do
-      defmodule unquote(name) do
-        # We don't allow function definition inside protocols
-        import Kernel, except: [
-          defmacrop: 1, defmacrop: 2, defmacro: 1, defmacro: 2,
-          defp: 1, defp: 2, def: 1, def: 2
-        ]
-
-        # Import the new dsl that holds the new def
-        import Protocol, only: [def: 1]
-
-        # Compile with debug info for consolidation
-        @compile :debug_info
-
-        # Set up a clear slate to store defined functions
-        @functions []
-        @fallback_to_any false
-
-        # Invoke the user given block
-        _ = unquote(block)
-
-        # Finalize expansion
-        unquote(after_defprotocol())
-      end
-    end
-  end
-
-  defp after_defprotocol do
-    quote bind_quoted: [builtin: __builtin__()] do
-      @doc false
-      @spec impl_for(term) :: atom | nil
-      Kernel.def impl_for(data)
-
-      # Define the implementation for structs.
-      #
-      # It simply delegates to struct_impl_for which is then
-      # optimized during protocol consolidation.
-      Kernel.def impl_for(%{__struct__: struct}) when :erlang.is_atom(struct) do
-        struct_impl_for(struct)
-      end
-
-      # Define the implementation for built-ins
-      :lists.foreach(fn {guard, mod} ->
-        target = Module.concat(__MODULE__, mod)
-
-        Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
-          case impl_for?(unquote(target)) do
-            true  -> unquote(target).__impl__(:target)
-            false -> any_impl_for()
-          end
-        end
-      end, builtin)
-
-      # Define a catch-all impl_for/1 clause to pacify Dialyzer (since
-      # destructuring opaque types is illegal, Dialyzer will think none of the
-      # previous clauses matches opaque types, and without this clause, will
-      # conclude that impl_for can't handle an opaque argument). This is a hack
-      # since it relies on Dialyzer not being smart enough to conclude that all
-      # opaque types will get the any_impl_for/0 implementation.
-      Kernel.def impl_for(_) do
-        any_impl_for()
-      end
-
-      @doc false
-      @spec impl_for!(term) :: atom | no_return
-      Kernel.def impl_for!(data) do
-        impl_for(data) || raise(Protocol.UndefinedError, protocol: __MODULE__, value: data)
-      end
-
-      # Internal handler for Any
-      if @fallback_to_any do
-        Kernel.defp any_impl_for(), do: __MODULE__.Any.__impl__(:target)
-      else
-        Kernel.defp any_impl_for(), do: nil
-      end
-
-      # Internal handler for Structs
-      Kernel.defp struct_impl_for(struct) do
-        target = Module.concat(__MODULE__, struct)
-        case impl_for?(target) do
-          true  -> target.__impl__(:target)
-          false -> any_impl_for()
-        end
-      end
-
-      # Check if compilation is available internally
-      Kernel.defp impl_for?(target) do
-        Code.ensure_compiled?(target) and
-          function_exported?(target, :__impl__, 1)
-      end
-
-      # Inline any and struct implementations
-      @compile {:inline, any_impl_for: 0, struct_impl_for: 1, impl_for?: 1}
-
-      unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
-        @type t :: term
-      end
-
-      # Store information as an attribute so it
-      # can be read without loading the module.
-      Module.register_attribute(__MODULE__, :protocol, persist: true)
-      @protocol [fallback_to_any: !!@fallback_to_any]
-
-      @doc false
-      @spec __protocol__(:module) :: __MODULE__
-      @spec __protocol__(:functions) :: unquote(Protocol.__functions_spec__(@functions))
-      @spec __protocol__(:consolidated?) :: false
-      @spec __protocol__(:impls) :: :not_consolidated
-      Kernel.def __protocol__(:module), do: __MODULE__
-      Kernel.def __protocol__(:functions), do: unquote(:lists.sort(@functions))
-      Kernel.def __protocol__(:consolidated?), do: false
-      Kernel.def __protocol__(:impls), do: :not_consolidated
-    end
-  end
-
-  @doc false
-  def __functions_spec__([]),
-    do: []
-  def __functions_spec__([head | tail]),
-    do: [:lists.foldl(&{:|, [], [&1, &2]}, head, tail), quote(do: ...)]
-
-  @doc false
-  def __impl__(protocol, opts) do
-    do_defimpl(protocol, :lists.keysort(1, opts))
-  end
-
-  defp do_defimpl(protocol, [do: block, for: for]) when is_list(for) do
-    for f <- for, do: do_defimpl(protocol, [do: block, for: f])
-  end
-
-  defp do_defimpl(protocol, [do: block, for: for]) do
-    # Unquote the implementation just later
-    # when all variables will already be injected
-    # into the module body.
-    impl =
-      quote unquote: false do
-        @doc false
-        @spec __impl__(:for) :: unquote(for)
-        @spec __impl__(:target) :: __MODULE__
-        @spec __impl__(:protocol) :: unquote(protocol)
-        def __impl__(:for),      do: unquote(for)
-        def __impl__(:target),   do: __MODULE__
-        def __impl__(:protocol), do: unquote(protocol)
-      end
-
-    quote do
-      protocol = unquote(protocol)
-      for      = unquote(for)
-      name     = Module.concat(protocol, for)
-
-      Protocol.assert_protocol!(protocol)
-      Protocol.__ensure_defimpl__(protocol, for, __ENV__)
-
-      defmodule name do
-        @behaviour protocol
-        @protocol  protocol
-        @for       for
-
-        unquote(block)
-
-        Module.register_attribute(__MODULE__, :protocol_impl, persist: true)
-        @protocol_impl [protocol: @protocol, for: @for]
-
-        unquote(impl)
-      end
-    end
-  end
-
-  @doc false
-  def __derive__(derives, for, %Macro.Env{} = env) when is_atom(for) do
-    struct =
-      if for == env.module do
-        Module.get_attribute(for, :struct) ||
-          raise "struct is not defined for #{inspect for}"
-      else
-        for.__struct__
-      end
-
-    :lists.foreach(fn
-      proto when is_atom(proto) ->
-        derive(proto, for, struct, [], env)
-      {proto, opts} when is_atom(proto) ->
-        derive(proto, for, struct, opts, env)
-    end, :lists.flatten(derives))
-
-    :ok
-  end
-
-  defp derive(protocol, for, struct, opts, env) do
-    extra = ", cannot derive #{inspect protocol} for #{inspect for}"
-    assert_protocol!(protocol, extra)
-    __ensure_defimpl__(protocol, for, env)
-    assert_impl!(protocol, Any, extra)
-
-    # Clean up variables from eval context
-    env  = %{env | vars: [], export_vars: nil}
-    args = [for, struct, opts]
-    impl = Module.concat(protocol, Any)
-
-    :elixir_module.expand_callback(env.line, impl, :__deriving__, args, env, fn
-      mod, fun, args ->
-        if function_exported?(mod, fun, length(args)) do
-          apply(mod, fun, args)
-        else
-          Module.create(Module.concat(protocol, for), quote do
-            Module.register_attribute(__MODULE__, :protocol_impl, persist: true)
-            @protocol_impl [protocol: unquote(protocol), for: unquote(for)]
-
-            @doc false
-            @spec __impl__(:target) :: unquote(impl)
-            @spec __impl__(:protocol) :: unquote(protocol)
-            @spec __impl__(:for) :: unquote(for)
-            def __impl__(:target),   do: unquote(impl)
-            def __impl__(:protocol), do: unquote(protocol)
-            def __impl__(:for),      do: unquote(for)
-          end, Macro.Env.location(env))
-        end
-    end)
-  end
-
-  @doc false
-  def __ensure_defimpl__(protocol, for, env) do
-    if Protocol.consolidated?(protocol) do
-      message =
-        "the #{inspect protocol} protocol has already been consolidated" <>
-        ", an implementation for #{inspect for} has no effect"
-      :elixir_errors.warn(env.line, env.file, message)
-    end
-    :ok
-  end
-
-  @doc false
-  def __spec__?(module, name, arity) do
-    signature = {name, arity}
-
-    specs = Module.get_attribute(module, :spec)
-    found =
-      :lists.map(fn {:spec, expr, pos} ->
-        if Kernel.Typespec.spec_to_signature(expr) == signature do
-          Module.store_typespec(module, :callback, {:callback, expr, pos})
-          true
-        end
-      end, specs)
-
-    :lists.any(& &1 == true, found)
-  end
-
-  ## Helpers
-
-  @doc false
-  def __builtin__ do
-    [is_tuple: Tuple,
-     is_atom: Atom,
-     is_list: List,
-     is_map: Map,
-     is_bitstring: BitString,
-     is_integer: Integer,
-     is_float: Float,
-     is_function: Function,
-     is_pid: PID,
-     is_port: Port,
-     is_reference: Reference]
-  end
-end