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

adapter: support OpenAI streaming (SSE) in /v1/chat/completions
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.
2026-09-12 12:51:34 +02:00 · 2026-09-12 10:50:47 +00:00 · 2026-09-11 18:44:45 +00:00 · 2026-09-11 15:36:15 +00:00 · 2026-09-10 14:35:28 +00:00 · 2026-09-10 07:21:42 +00:00
380 changed files with 1182 additions and 78221 deletions
@@ -1,17 +1,11 @@
-/.eunit/*
-/.release
-/lib/*/ebin/*
-/lib/*/tmp
-/lib/*/test/tmp
-/lib/elixir/src/elixir.app.src
-/lib/elixir/src/*_lexer.erl
-/lib/elixir/src/*_parser.erl
-/lib/elixir/test/ebin
-/deps/*
-/ebin
-/rel/elixir
+.formatter.exs
+/_build/
+/cover/
+/deps/
+/doc/
+/.fetch
 erl_crash.dump
-.dialyzer_plt
-.dialyzer.base_plt
-.*.swp
-docs
+*.ez
+n8n_openai_adapter-*.tar
+/tmp/
+/result
@@ -1,9 +0,0 @@
-language: erlang
-script: "make compile && make test"
-notifications:
-  irc: "irc.freenode.org#elixir-lang"
-  recipients:
-    - jose.valim@plataformatec.com.br
-    - yrashk@gmail.com
-otp_release:
-  - R16B
@@ -1,374 +0,0 @@
-# v0.9.2 (2013-06-13)
-
-* enhancements
-  * [ExUnit] `capture_io` now captures prompt by default
-  * [Mix] Automatically import git dependencies from Rebar
-  * [Mix] Support for dependencies directly from the umbrella application
-  * [Regex] Add `Regex.escape`
-  * [String] Add `String.contains?`
-  * [URI] Implement `Binary.Chars` (aka `to_binary`) for `URI.Info`
-
-* bug fix
-  * [HashDict] Ensure HashDict uses exact match throughout its implementation
-  * [IEx] Do not interpret ANSI codes in IEx results
-  * [IEx] Ensure --cookie is set before accessing remote shell
-  * [Kernel] Do not ignore nil when dispatching protocols to avoid infinite loops
-  * [Mix] Fix usage of shell expressions in `Mix.Shell.cmd`
-  * [Mix] Start the application by default on escripts
-
-* deprecations
-  * [Regex] `Regex.index/2` is deprecated in favor `Regex.run/3`
-  * [Kernel] `super` no longer supports implicit arguments
-
-* backwards incompatible changes
-  * [Kernel] The `=~` operator now returns true or false instead of an index
-
-# v0.9.1 (2013-05-30)
-
-* enhancements
-  * [IEx] Limit the number of entries kept in history and allow it to be configured
-  * [Kernel] Add `String.start_with?` and `String.end_with?`
-  * [Typespec] Allow keywords, e.g. `[foo: integer, bar: boolean | module]`, in typespecs
-
-* bug fix
-  * [Dict] `Enum.to_list` and `Dict.to_list` now return the same results for dicts
-  * [IEx] Enable shell customization via the `IEx.Options` module
-  * [Kernel] Fix a bug where `unquote_splicing` did not work on the left side of a stab op
-  * [Kernel] Unused functions with cyclic dependencies are now also warned as unused
-  * [Mix] Fix a bug where `mix deps.get` was not retrieving nested dependencies
-  * [Record] Fix a bug where nested records cannot be defined
-  * [Record] Fix a bug where a record named Record cannot be defined
-
-# v0.9.0 (2013-05-23)
-
-* enhancements
-  * [ExUnit] `ExUnit.CaptureIO` now accepts an input to be used during capture
-  * [IEx] Add support for .iex files that are loaded during shell's boot process
-  * [IEx] Add `import_file/1` helper
-
-* backwards incompatible changes
-  * [Enum] `Enum.Iterator` was replaced by the more composable and functional `Enumerable` protocol which supports reductions
-  * [File] `File.iterator/1` and `File.biniterator/1` have been removed in favor of the safe `File.iterator!/1` and `File.biniterator!/1` ones
-  * [Kernel] Erlang R15 is no longer supported
-  * [Kernel] Elixir modules are now represented as `Elixir.ModuleName` (using `.` instead of `-` as separator)
-
-# v0.8.3 (2013-05-22)
-
-* enhancements
-  * [CLI] Flags `-p` and `-pr` fails if pattern match no files
-  * [CLI] Support `--hidden` and `--cookie` flags for distributed Erlang
-  * [Enum] Add `Enum.to_list/1`, `Enum.member?/2`, `Enum.uniq/2`, `Enum.max/1`, `Enum.max/2`, `Enum.min/1` and `Enum.min/2`
-  * [ExUnit] Add `ExUnit.CaptureIO` for IO capturing during tests
-  * [ExUnit] Consider load time on ExUnit time reports
-  * [IEx] Support `ls` with colored output
-  * [IEx] Add `#iex:break` to break incomplete expressions
-  * [Kernel] Add `Enum.at`, `Enum.fetch` and `Enum.fetch!`
-  * [Kernel] Add `String.to_integer` and `String.to_float`
-  * [Kernel] Add `Dict.take`, `Dict.drop`, `Dict.split`, `Dict.pop` and `Dict.fetch!`
-  * [Kernel] Many optimizations for code compilation
-  * [Kernel] `in` can be used with right side expression outside guards
-  * [Kernel] Add `Node.get_cookie/0` and `Node.set_cookie/2`
-  * [Kernel] Add `__DIR__`
-  * [Kernel] Expand macros and attributes on quote, import, alias and require
-  * [Kernel] Improve warnings related to default arguments
-  * [Keyword] Add `Keyword.delete_first/2`
-  * [Mix] Add `local.rebar` to download a local copy of rebar, and change `deps.compile` to use it if needed
-  * [Mix] Support umbrella applications
-  * [Mix] Load beam files available at `MIX_PATH` on CLI usage
-  * [String] Add `String.valid?` and `String.valid_character?`
-
-* bug fix
-  * [ExUnit] Handle exit messages from in ExUnit
-  * [ExUnit] Failures on ExUnit's setup_all now invalidates all tests
-  * [Kernel] Ensure we don't splice keyword args unecessarily
-  * [Kernel] Private functions used by private macros no longer emit an unused warning
-  * [Kernel] Ensure Elixir won't trip on empty receive blocks
-  * [Kernel] `String.slice` now returns an empty string when out of range by 1
-  * [Mix] Generate manifest files after compilation to avoid depending on directory timestamps and to remove unused .beam files
-  * [Path] `Path.expand/2` now correctly expands `~` in the second argument
-  * [Regex] Fix badmatch with `Regex.captures(%r/(.)/g, "cat")`
-  * [URI] Downcase host and scheme and URIs
-
-* deprecations
-  * [Code] `Code.eval` is deprecated in favor of `Code.eval_string`
-  * [Exception] `Exception.format_entry` is deprecated in favor of `Exception.format_stacktrace_entry`
-  * [ExUnit] `assert left inlist right` is deprecated in favor of `assert left in right`
-  * [IO] `IO.getb` is deprecated in favor of `IO.getn`
-  * [List] `List.member?/2` is deprecated in favor of `Enum.member?/2`
-  * [Kernel] `var_context` in quote was deprecated in favor of `context`
-  * [Kernel] `Enum.at!` and `Dict.get!` is deprecated in favor of `Enum.fetch!` and `Dict.fetch!`
-
-* backwards incompatible changes
-  * [Dict] `List.Dict` was moved to `ListDict`
-  * [IO] `IO.gets`, `IO.getn` and friends now return binaries when reading from stdio
-  * [Kernel] Precedence of `|>` has changed to lower to support constructs like `1..5 |> Enum.to_list`
-  * [Mix] `mix escriptize` now receives arguments as binaries
-
-# v0.8.2 (2013-04-20)
-
-* enhancements
-  * [ExUnit] Use ANSI escape codes in CLI output
-  * [ExUnit] Include suite run time on CLI results
-  * [ExUnit] Add support to doctests, allowing test cases to be generated from code samples
-  * [File] Add `File.ls` and `File.ls!`
-  * [IEx] Support `pwd` and `cd` helpers
-  * [Kernel] Better error reporting for invalid bitstring generators
-  * [Kernel] Improve meta-programming by allowing `unquote` on `def/2`, `defp/2`, `defmacro/2` and `defmacrop/2`
-  * [Kernel] Add support to R16B new functions: `insert_elem/3` and `delete_elem/2`
-  * [Kernel] Import conflicts are now lazily handled. If two modules import the same functions, it will fail only if the function is invoked
-  * [Mix] Support `--cover` on mix test and `test_coverage` on Mixfiles
-  * [Record] Each record now provides `Record.options` with the options supported by its `new` and `update` functions
-
-* bug fix
-  * [Binary] inspect no longer escapes standalone hash `#`
-  * [IEx] The `h` helper can now retrieve docs for special forms
-  * [Kernel] Record optimizations were not being triggered in functions inside the record module
-  * [Kernel] Aliases defined inside macros should be carried over
-  * [Kernel] Fix a bug where nested records could not use the Record[] syntax
-  * [Path] Fix a bug on `Path.expand` when expanding paths starting with `~`
-
-* deprecations
-  * [Kernel] `setelem/3` is deprecated in favor of `set_elem/3`
-  * [Kernel] `function(:is_atom, 1)` is deprecated in favor of `function(is_atom/1)`
-
-* backwards incompatible changes
-  * [Kernel] `unquote` now only applies to the closest quote. If your code contains a quote that contains another quote that calls unquote, it will no longer work. Use `Macro.escape` instead and pass your quoted contents up in steps, for example:
-
-            quote do
-              quote do: unquote(x)
-            end
-
-      should become:
-
-            quote do
-              unquote(Macro.escape(x))
-            end
-
-# v0.8.1 (2013-02-17)
-
-* enhancements
-  * [ExUnit] Tests can now receive metadata set on setup/teardown callbacks
-  * [ExUnit] Add support to ExUnit.CaseTemplate to share callbacks in between test cases
-  * [IO] Add `IO.ANSI` to make it easy to write ANSI escape codes
-  * [Kernel] Better support for Unicode lists
-  * [Kernel] Reduce variables footprint in `case`/`receive` clauses
-  * [Kernel] Disable native compilation when on_load attributes is present to work around an Erlang bug
-  * [Macro] `Macro.expand` also considers macros from the current `__ENV__` module
-  * [Mix] Improve support for compilation of `.erl` files
-  * [Mix] Add support for compilation of `.yrl` and `.xrl` files
-  * [OptionParser] Switches are now overridden by default but can be kept in order if chosen
-  * [Typespec] Better error reporting for invalid typespecs
-
-* bug fix
-  * [Mix] Allow Mix projects to be generated with just one letter
-
-* backwards incompatible changes
-  * [Kernel] `before_compile` and `after_compile` callbacks now receive the environment as first argument instead of the module
-
-* deprecations
-  * [ExUnit] Explicitly defined test/setup/teardown functions are deprecated
-  * [Kernel] Tidy up and clean `quote` API
-  * [Kernel] Old `:local.(args)` syntax is deprecated
-  * [Process] `Process.self` is deprecated in favor `Kernel.self`
-
-# v0.8.0 (2013-01-28)
-
-* enhancements
-  * [Binary] Support `<< "string" :: utf8 >>` as in Erlang
-  * [Binary] Support `\a` escape character in binaries
-  * [Binary] Support syntax shortcut for specifying size in bit syntax
-  * [CLI] Support `--app` option to start an application and its dependencies
-  * [Dict] Support `put_new` in `Dict` and `Keyword`
-  * [Dict] Add `ListDict` and a faster `HashDict` implementation
-  * [ExUnit] ExUnit now supports multiple runs in the same process
-  * [ExUnit] Failures in ExUnit now shows a tailored stacktrace
-  * [ExUnit] Introduce `ExUnit.ExpectationError` to provide better error messages
-  * [Kernel] Introduce `Application.Behaviour` to define application module callbacks
-  * [Kernel] Introduce `Supervisor.Behaviour` to define supervisors callbacks
-  * [Kernel] More optimizations were added to Record handling
-  * [Kernel] `?\x` and `?\` are now supported ways to retrieve a codepoint
-  * [Kernel] Octal numbers can now be defined as `0777`
-  * [Kernel] Improve macros hygiene regarding variables, aliases and imports
-  * [Mix] Mix now starts the current application before run, iex, test and friends
-  * [Mix] Mix now provides basic support for compiling `.erl` files
-  * [Mix] `mix escriptize` only generates escript if necessary and accept `--force` and `--no-compile` as options
-  * [Path] Introduce `Path` module to hold filesystem paths related functions
-  * [String] Add `String.capitalize` and `String.slice`
-  * [System] Add `System.tmp_dir`, `System.cwd` and `System.user_home`
-
-* bug fix
-  * [Kernel] `import` with `only` accepts functions starting with underscore
-  * [String] `String.first` and `String.last` return nil for empty binaries
-  * [String] `String.rstrip` and `String.lstrip` now verify if argument is a binary
-  * [Typespec] Support `...` inside typespec's lists
-
-* backwards incompatible changes
-  * [Kernel] The AST now allows metadata to be attached to each node. This means the second item in the AST is no longer an integer (representing the line), but a keywords list. Code that relies on the line information from AST or that manually generate AST nodes need to be properly updated
-
-* deprecations
-  * [Dict] Deprecate `Binary.Dict` and `OrdDict` in favor of `HashDict` and `ListDict`
-  * [File] Deprecate path related functions in favor of the module `Path`
-  * [Kernel] The `/>` operator has been deprecated in favor of `|>`
-  * [Mix] `Mix.Project.sources` is deprecated in favor of `Mix.Project.config_files`
-  * [Mix] `mix iex` is no longer functional, please use `iex -S mix`
-  * [OptionParser] `:flags` option was deprecated in favor of `:switches` to support many types
-
-# v0.7.2 (2012-12-04)
-
-* enhancements
-  * [CLI] `--debug-info` is now true by default
-  * [ExUnit] Make ExUnit exit happen in two steps allowing developers to add custom `at_exit` hooks
-  * [IEx] Many improvements to helpers functions `h/1`, `s/1` and others
-  * [Kernel] Functions defined with `fn` can now handle many clauses
-  * [Kernel] Raise an error if clauses with different arities are defined in the same function
-  * [Kernel] `function` macro now accepts arguments in `M.f/a` and `f/a` formats
-  * [Macro] Improvements to `Macro.to_binary`
-  * [Mix] Mix now echoes the output as it comes when executing external commands such as git or rebar
-  * [Mix] Mix now validates `application` callback's values
-  * [Record] Record accessors are now optimized and can be up to 6x faster in some cases
-  * [String] Support `\xXX` and `\x{HEX}` escape sequences in strings, char lists and regexes
-
-* bug fix
-  * [Bootstrap] Compiling Elixir source no longer fails if environment variables contain utf-8 entries
-  * [IEx] IEx will now wait for all command line options to be processed before starting
-  * [Kernel] Ensure proper stacktraces when showing deprecations
-
-* deprecations
-  * [Enum] `Enum.qsort` is deprecated in favor of `Enum.sort`
-  * [List] `List.sort` and `List.uniq` have been deprecated in favor of their `Enum` counterparts
-  * [Record] Default-based generated functions are deprecated
-  * [Typespec] Enhancements and deprecations to the `@spec/@callback` and the fun type syntax
-
-# v0.7.1 (2012-11-18)
-
-* enhancements
-  * [IEx] Only show documented functions and also show docs for default generated functions
-  * [IO] Add `IO.binread`, `IO.binwrite` and `IO.binreadline` to handle raw binary file operations
-  * [ExUnit] Add support for user configuration at `HOME/.ex_unit.exs`
-  * [ExUnit] Add support for custom formatters via a well-defined behaviour
-  * [Kernel] Add support for `defrecordp`
-  * [Kernel] Improved dialyzer support
-  * [Kernel] Improved error messages when creating functions with aliases names
-  * [Mix] Improve SCM behaviour to allow more robust integration
-  * [Mix] Changing deps information on `mix.exs` forces users to fetch new dependencies
-  * [Mix] Support (parallel) requires on mix run
-  * [Mix] Support `-q` when running tests to compile only changed files
-  * [String] Support `String.downcase` and `String.upcase` according to Unicode 6.2.0
-  * [String] Add support for graphemes in `String.length`, `String.at` and others
-  * [Typespec] Support `@opaque` as attribute
-  * [Typespec] Define a default type `t` for protocols and records
-  * [Typespec] Add support for the access protocol in typespecs
-
-* bug fix
-  * [Kernel] Fix an issue where variables inside clauses remained unassigned
-  * [Kernel] Ensure `defoverridable` functions can be referred in many clauses
-  * [Kernel] Allow keywords as function names when following a dot (useful when integrating with erlang libraries)
-  * [File] File is opened by default on binary mode instead of utf-8
-
-* deprecations
-  * [Behaviour] `defcallback/1` is deprecated in favor of `defcallback/2` which matches erlang `@callbacks`
-  * [Enum] `Enum.times` is deprecated in favor of using ranges
-  * [System] `halt` moved to `System` module
-
-# v0.7.0 (2012-10-20)
-
-* enhancements
-  * [Behaviour] Add Behaviour with a simple callback DSL to define callbacks
-  * [Binary] Add a Dict binary that converts its keys to binaries on insertion
-  * [Binary] Optimize `Binary.Inspect` and improve inspect for floats
-  * [CLI] Support `--detached` option
-  * [Code] `Code.string_to_ast` supports `:existing_atoms_only` as an option in order to guarantee no new atoms is generated when parsing the code
-  * [EEx] Support `<%%` and `<%#` tags
-  * [ExUnit] Support `after_spawn` callbacks which are invoked after each process is spawned
-  * [ExUnit] Support context data in `setup_all`, `setup`, `teardown` and `teardown_all` callbacks
-  * [IEx] Support `after_spawn` callbacks which are invoked after each process is spawned
-  * [Kernel] Better error messages when invalid options are given to `import`, `alias` or `require`
-  * [Kernel] Allow partial application on literals, for example: `{ &1, &2 }` to build tuples or `[&1|&2]` to build cons cells
-  * [Kernel] Added `integer_to_binary` and `binary_to_integer`
-  * [Kernel] Added `float_to_binary` and `binary_to_float`
-  * [Kernel] Many improvements to `unquote` and `unquote_splicing`. For example, `unquote(foo).unquote(bar)(args)` is supported and no longer need to be written via `apply`
-  * [Keyword] Keyword list is no longer ordered according to Erlang terms but the order in which they are specified
-  * [List] Add `List.keyreplace` and `List.keystore`
-  * [Macro]  Support `Macro.safe_term` which returns `:ok` if an expression does not execute code and is made only of raw data types
-  * [Mix] Add support for environments - the current environment can be set via `MIX_ENV`
-  * [Mix] Add support for handling and fetching dependencies' dependencies
-  * [Module] Support module creation via `Module.create`
-  * [Range] Support decreasing ranges
-  * [Record] Improvements to the Record API, added `Record.defmacros`
-  * [Regex] Add `:return` option to `Regex.run` and `Regex.scan`
-  * [String] Add a String module responsible for handling UTf-8 binaries
-
-* bug fix
-  * [File] `File.cp` and `File.cp_r` now preserves the file's mode
-  * [IEx] Fix a bug where printing to `:stdio` on `IEx` was causing it to hang
-  * [Macro] Fix a bug where quoted expressions were not behaving the same as their non-quoted counterparts
-  * [Mix] `mix deps.get [DEPS]` now only gets the specified dependencies
-  * [Mix] Mix now exits with status 1 in case of failures
-  * [Protocol] Avoid false positives on protocol dispatch (a bug caused the dispatch to be triggered to an invalid protocol)
-
-* backwards incompatible changes
-  * [ExUnit] `setup` and `teardown` callbacks now receives the test name as second argument
-  * [Kernel] Raw function definition with `def/4`, `defp/4`, `defmacro/4`, `defmacrop/4` now evaluates all arguments. The previous behaviour was accidental and did not properly evaluate all arguments
-  * [Kernel] Change tuple-related (`elem` and `setelem`), Enum functions (`find_index`, `nth!` and `times`) and List functions (List.key*) to zero-index
-
-* deprecations
-  * [Code] `Code.require_file` and `Code.load_file` now expect the full name as argument
-  * [Enum] `List.reverse/1` and `List.zip/2` were moved to `Enum`
-  * [GenServer] Rename `GenServer.Behavior` to `GenServer.Behaviour`
-  * [Kernel] Bitstring syntax now uses `::` instead of `|`
-  * [Kernel] `Erlang.` syntax is deprecated in favor of simply using atoms
-  * [Module] `Module.read_attribute` and `Module.add_attribute` deprecated in favor of `Module.get_attribute` and `Module.put_attribute` which mimics Dict API
-
-# v0.6.0 (2012-08-01)
-
-* incompatible changes
-  * [Kernel] Compile files now follow `Elixir-ModuleName` convention to solve issues with Erlang embedded mode. This removes the `__MAIN__` pseudo-variable as modules are now located inside `Elixir` namespace
-  * [Kernel] `__using__` callback triggered by `use` now receives just one argument. Caller information can be accessed via macros using `__CALLER__`
-  * [Kernel] Comprehensions syntax changed to be more compatible with Erlang behavior
-  * [Kernel] loop and recur are removed in favor of recursion with named functions
-  * [Module] Removed data functions in favor of unifying the attributes API
-
-* deprecations
-  * [Access] The semantics of the access protocol were reduced from a broad query API to simple data structure key-based access
-  * [ExUnit] Some assertions are deprecated in favor of simply using `assert()`
-  * [File] `File.read_info` is deprecated in favor of `File.stat`
-  * [IO] `IO.print` is deprecated in favor of `IO.write`
-  * [Kernel] Deprecate `__LINE__` and `__FUNCTION__` in favor of `__ENV__.line` and `__ENV__.function`
-  * [Kernel] Deprecate `in_guard` in favor of `__CALLER__.in_guard?`
-  * [Kernel] `refer` is deprecated in favor of `alias`
-  * [Module] `Module.add_compile_callback(module, target, callback)` is deprecated in favor of `Module.put_attribute(module, :before_compile, { target, callback })`
-  * [Module] `Module.function_defined?` is deprecated in favor of `Module.defines?`
-  * [Module] `Module.defined_functions` is deprecated in favor of `Module.definitions_in`
-
-* enhancements
-  * [Enum] Enhance Enum protocol to support `Enum.count`
-  * [Enum] Optimize functions when a list is given as collection
-  * [Enum] Add `find_index`, `nth!` and others
-  * [ExUnit] Support setup and teardown callbacks
-  * [IEx] IEx now provides autocomplete if the OS supports tty
-  * [IEx] IEx now supports remsh
-  * [IEx] Elixir now defaults to compile with documentation and `d` can be used in IEx to print modules and functions documentation
-  * [IEx] Functions `c` and `m` are available in IEx to compile and print available module information. Functions `h` and `v` are available to show history and print previous commands values
-  * [IO/File] Many improvements to `File` and `IO` modules
-  * [Kernel] Operator `!` is now allowed in guard clauses
-  * [Kernel] Introduce operator `=~` for regular expression matches
-  * [Kernel] Compiled docs now include the function signature
-  * [Kernel] `defmodule` do not start a new variable scope, this improves meta-programming capabilities
-  * [Kernel] quote special form now supports line and unquote as options
-  * [Kernel] Document the macro `@` and allow attributes to be read inside functions
-  * [Kernel] Add support to the `%R` sigil. The same as `%r`, but without interpolation or escaping. Both implementations were also optimized to generate the regex at compilation time
-  * [Kernel] Add `__ENV__` which returns a `Macro.Env` record with information about the compilation environment
-  * [Kernel] Add `__CALLER__` inside macros which returns a `Macro.Env` record with information about the calling site
-  * [Macro] Add `Macro.expand`, useful for debugging what a macro expands to
-  * [Mix] First Mix public release
-  * [Module] Add support to `@before_compile` and `@after_compile` callbacks. The first receives the module name while the latter receives the module name and its object code
-  * [OptionParser] Make OptionParser public, add support to flags and improved switch parsing
-  * [Range] Add a Range module with support to `in` operator (`x in 1..3`) and iterators
-  * [Record] Allow `Record[_: value]` to set a default value to all records fields, as in Erlang
-  * [Record] Records now provide a `to_keywords` function
-  * [Regex] Back references are now properly supported
-  * [System] Add `System.find_executable`
-
-# v0.5.0 (2012-05-24)
-
-* First official release
@@ -1,178 +0,0 @@
-# Contributing to Elixir
-
-Please take a moment to review this document in order to make the contribution
-process easy and effective for everyone involved!
-
-## Using the issue tracker
-
-The issue tracker is the preferred channel for [bug reports](#bugs-reports),
-[features requests](#feature-requests) and [submitting pull
-requests](#pull-requests), but please **do not** use the issue tracker for
-personal support requests. Instead, use
-[the mailing list](http://groups.google.com/group/elixir-lang-talk),
-[Stack Overflow](http://stackoverflow.com/questions/ask?tags=elixir), or
-[#elixir-lang](irc://chat.freenode.net/elixir-lang) on Freenode).
-
-We do our best to keep the issues tracker tidy and organized, making it useful
-for everyone. For example, we classify open issues per application and perceived
-difficulty of the issue, making it easier for developers to
-[contribute to Elixir](#contributing).
-
-## Bug reports
-
-A bug is a _demonstrable problem_ that is caused by the code in the repository.
-Good bug reports are extremely helpful - thank you!
-
-Guidelines for bug reports:
-
-1. **Use the GitHub issue search** &mdash; check if the issue has already been
-   reported.
-
-2. **Check if the issue has been fixed** &mdash; try to reproduce it using the
-   latest `master` or development branch in the repository.
-
-3. **Isolate the problem** &mdash; ideally create a reduced test
-   case.
-
-A good bug report shouldn't leave others needing to chase you up for more
-information. Please try to be as detailed as possible in your report. What is
-your environment? What steps will reproduce the issue? What version of Erlang
-and Elixir experience the problem? What would you expect to be the outcome?
-All these details will help people to fix any potential bugs.
-
-Example:
-
-> Short and descriptive example bug report title
->
-> A summary of the issue and the environment in which it occurs. If suitable,
-> include the steps required to reproduce the bug.
->
-> 1. This is the first step
-> 2. This is the second step
-> 3. Further steps, etc.
->
-> `<url>` - a link to the reduced test case (e.g. a GitHub Gist)
->
-> Any other information you want to share that is relevant to the issue being
-> reported. This might include the lines of code that you have identified as
-> causing the bug, and potential solutions (and your opinions on their
-> merits).
-
-## Feature requests
-
-Feature requests are welcome. But take a moment to find out whether your idea
-fits with the scope and aims of the project. It's up to *you* to make a strong
-case to convince the project's developers of the merits of this feature. Please
-provide as much detail and context as possible.
-
-## Contributing
-
-We incentivate everyone to contribute to Elixir and help us tackle
-existing issues! To do so, there are a few things you need to know
-about the code. First, Elixir code is divided in applications inside
-the `lib` folder:
-
-* `elixir` - Contains Elixir's kernel and stdlib
-
-* `eex` - Template engine that allows you to embed Elixir
-
-* `ex_unit` - Simple test framework that ships with Elixir
-
-* `iex` — IEx, Elixir's interactive shell
-
-* `mix` — Elixir's build tool
-
-You can run all tests in the root directory with `make test` and you can
-also run tests for a specific framework `make test_#{NAME}`, for example,
-`make test_ex_unit`.
-
-With tests running and passing, you are ready to contribute to Elixir and
-send your pull requests.
-
-## Pull requests
-
-Good pull requests - patches, improvements, new features - are a fantastic
-help. They should remain focused in scope and avoid containing unrelated
-commits.
-
-**IMPORTANT**: By submitting a patch, you agree that your work will be made
-public forever and will be licensed under the license used by the project.
-
-If you have any significant pull request in mind (e.g. implementing features,
-refactoring code, porting to a different language), **please ask first**
-otherwise you risk spending a lot of time working on something that the
-project's developers might not want to merge into the project.
-
-Please adhere to the coding conventions in the project (indentation,
-accurate comments, etc.) and don't forget to add your own tests and
-documentation. When working with git, we recommend the following process
-in order to craft an excellent pull request:
-
-1. [Fork](http://help.github.com/fork-a-repo/) the project, clone your fork,
-   and configure the remotes:
-
-   ```bash
-   # Clone your fork of the repo into the current directory
-   git clone https://github.com/<your-username>/elixir
-   # Navigate to the newly cloned directory
-   cd elixir
-   # Assign the original repo to a remote called "upstream"
-   git remote add upstream https://github.com/elixir-lang/elixir
-   ```
-
-2. If you cloned a while ago, get the latest changes from upstream:
-
-   ```bash
-   git checkout master
-   git pull upstream master
-   ```
-
-3. Create a new topic branch (off of `master`) to contain your feature, change,
-   or fix.
-
-   **IMPORTANT**: Making changes in `master` is discouraged. You should always
-   keep your local `master` in sync with upstream `master` and make your
-   changes in topic branches.
-
-   ```bash
-   git checkout -b <topic-branch-name>
-   ```
-
-4. Commit your changes in logical chunks. Keep your commit messages organized,
-   with a short description in the first line and more detailed information on
-   the following lines. Feel free to use Git's
-   [interactive rebase](https://help.github.com/articles/interactive-rebase)
-   feature to tidy up your commits before making them public.
-
-5. Push your topic branch up to your fork:
-
-   ```bash
-   git push origin <topic-branch-name>
-   ```
-
-6. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/)
-    with a clear title and description.
-
-7. If you haven't updated your pull request for a while, you should consider
-   rebasing on master and resolving any conflicts.
-
-   **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You
-   should always `git rebase` on `master` to bring your changes up to date when
-   necessary.
-
-   ```bash
-   git checkout master
-   git pull upstream master
-   git checkout <your-topic-branch>
-   git rebase master
-   ```
-
-We have saved some excellent pull requests we have received in the past in case
-you are looking for some examples:
-
-* https://github.com/elixir-lang/elixir/pull/992
-* https://github.com/elixir-lang/elixir/pull/1041
-* https://github.com/elixir-lang/elixir/pull/1058
-* https://github.com/elixir-lang/elixir/pull/1059
-
-Thank you for your contributions!
@@ -1,10 +0,0 @@
-LEGAL NOTICE INFORMATION
------------------------
-
-All the files in this distribution are covered under either Elixir's
-license (see the file LICENSE) except the files mentioned below that
-contains sections that are under Erlang's License (EPL):
-
-lib/elixir/src/elixir_glob.erl
-lib/elixir/src/elixir_parser.erl (generated by build scripts)
-
@@ -1,13 +0,0 @@
-Copyright 2012-2013 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.
@@ -1,154 +0,0 @@
-REBAR := $(shell echo `pwd`/rebar)
-ELIXIRC := bin/elixirc --ignore-module-conflict $(ELIXIRC_OPTS)
-ERLC := erlc -I lib/elixir/include
-ERL := erl -I lib/elixir/include -noshell -pa lib/elixir/ebin
-VERSION := $(strip $(shell cat VERSION))
-INSTALL_PATH := /usr/local
-
-.PHONY: install compile erlang elixir dialyze test clean docs release_docs release_zip release_erl
-.NOTPARALLEL: compile
-
-#==> Templates
-
-define APP_TEMPLATE
-$(1): lib/$(1)/ebin/Elixir.$(2).beam lib/$(1)/ebin/$(1).app
-
-lib/$(1)/ebin/$(1).app:
-	@ cd lib/$(1) && ../../bin/elixir -e "Mix.Server.start_link(:dev)" -r mix.exs -e "Mix.Task.run('compile.app')"
-
-lib/$(1)/ebin/Elixir.$(2).beam: $(wildcard lib/$(1)/lib/*.ex) $(wildcard lib/$(1)/lib/*/*.ex) $(wildcard lib/$(1)/lib/*/*/*.ex)
-	@ echo "==> $(1) (compile)"
-	@ $$(ELIXIRC) "lib/$(1)/lib/**/*.ex" -o lib/$(1)/ebin
-
-test_$(1): $(1)
-	@ echo "==> $(1) (exunit)"
-	@ 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
-	@ rm -rf lib/elixir/src/elixir.app.src
-	@ cp src/elixir.app.src lib/elixir/src/elixir.app.src
-
-erlang:
-	@ 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: kernel lib/eex/ebin/Elixir.EEx.beam mix ex_unit eex iex
-
-kernel: $(KERNEL) VERSION
-$(KERNEL): lib/elixir/lib/*.ex lib/elixir/lib/*/*.ex
-	@ if [ ! -f $(KERNEL) ]; then                       \
-		echo "==> bootstrap (compile)";                 \
-		$(ERL) -s elixir_compiler core -s erlang halt;  \
-	fi
-	@ echo "==> kernel (compile)";
-	@ $(ELIXIRC) "lib/elixir/lib/**/*.ex" -o lib/elixir/ebin;
-	@ $(MAKE) unicode
-	@ rm -rf lib/elixir/ebin/elixir.app
-	@ cd lib/elixir && $(REBAR) compile
-
-unicode: $(UNICODE)
-$(UNICODE): lib/elixir/priv/unicode.ex lib/elixir/priv/UnicodeData.txt lib/elixir/priv/NamedSequences.txt
-	@ echo "==> unicode (compile)";
-	@ echo "This step can take up to a minute to compile in order to embed the Unicode database"
-	@ $(ELIXIRC) lib/elixir/priv/unicode.ex -o lib/elixir/ebin;
-
-$(eval $(call APP_TEMPLATE,ex_unit,ExUnit))
-$(eval $(call APP_TEMPLATE,eex,EEx))
-$(eval $(call APP_TEMPLATE,mix,Mix))
-$(eval $(call APP_TEMPLATE,iex,IEx))
-
-install: compile
-	@ echo "==> elixir (install)"
-	for dir in lib/*; do \
-		install -m755 -d $(INSTALL_PATH)/lib/elixir/$$dir/ebin; \
-		install -m644 $$dir/ebin/* $(INSTALL_PATH)/lib/elixir/$$dir/ebin; \
-	done
-	install -m755 -d $(INSTALL_PATH)/lib/elixir/bin
-	install -m755 $(filter-out %.bat, $(wildcard bin/*)) $(INSTALL_PATH)/lib/elixir/bin
-	install -m755 -d $(INSTALL_PATH)/bin
-	ln -sf $(INSTALL_PATH)/lib/elixir/bin/* $(INSTALL_PATH)/bin
-
-clean:
-	@ cd lib/elixir && $(REBAR) clean
-	rm -rf ebin
-	rm -rf lib/*/ebin
-	rm -rf lib/*/test/tmp
-	rm -rf lib/mix/test/fixtures/git_repo
-	rm -rf lib/*/tmp
-	rm -rf lib/elixir/src/elixir.app.src
-	rm -rf lib/elixir/src/*_lexer.erl
-	rm -rf lib/elixir/src/*_parser.erl
-	rm -rf lib/elixir/test/ebin
-
-#==> Release tasks
-
-SOURCE_REF = $(shell head="$$(git rev-parse HEAD)" tag="$$(git tag --points-at $$head | tail -1)" ; echo "$${tag:-$$head}\c")
-
-docs: compile ../ex_doc/bin/ex_doc
-	mkdir -p ebin
-	rm -rf docs
-	cp -R -f lib/*/ebin/*.beam ./ebin
-	bin/elixir ../ex_doc/bin/ex_doc "Elixir" "$(VERSION)" -m Kernel -u "https://github.com/elixir-lang/elixir" --source-ref "$(call SOURCE_REF)"
-	rm -rf ebin
-
-../ex_doc/bin/ex_doc:
-	@ echo "ex_doc is not found in ../ex_doc as expected. See README for more information."
-	@ false
-
-release_zip: compile
-	rm -rf v$(VERSION).zip
-	zip -9 -r v$(VERSION).zip bin CHANGELOG.md LEGAL lib/*/ebin LICENSE README.md rel VERSION
-
-release_docs: docs
-	cd ../elixir-lang.github.com && git checkout master
-	rm -rf ../elixir-lang.github.com/docs/master
-	mv docs ../elixir-lang.github.com/docs/master
-
-release_erl: compile
-	@ rm -rf rel/elixir
-	@ cd rel && ../rebar generate
-
-#==> Tests tasks
-
-test: test_erlang test_elixir
-
-test_erlang: compile
-	@ echo "==> elixir (eunit)"
-	@ mkdir -p lib/elixir/test/ebin
-	@ $(ERLC) -pa lib/elixir/ebin -o lib/elixir/test/ebin lib/elixir/test/erlang/*.erl
-	@ $(ERL) -pa lib/elixir/test/ebin -s test_helper test -s erlang halt;
-	@ echo
-
-test_elixir: test_kernel test_ex_unit test_doc_test test_mix test_eex test_iex
-
-test_doc_test: compile
-	@ echo "==> doctest (exunit)"
-	@ cd lib/elixir && ../../bin/elixir -r "test/doc_test.exs";
-
-test_kernel: compile
-	@ echo "==> kernel (exunit)"
-	@ cd lib/elixir && ../../bin/elixir -r "test/elixir/test_helper.exs" -pr "test/elixir/**/*_test.exs";
-
-.dialyzer.base_plt:
-	@ echo "==> Adding Erlang/OTP basic applications to a new base PLT"
-	@ dialyzer --output_plt .dialyzer.base_plt --build_plt --apps erts kernel stdlib compiler syntax_tools inets crypto ssl
-
-dialyze: .dialyzer.base_plt
-	@ rm -f .dialyzer_plt
-	@ cp .dialyzer.base_plt .dialyzer_plt
-	@ echo "==> Adding Elixir to PLT..."
-	@ dialyzer --plt .dialyzer_plt --add_to_plt -r lib/elixir/ebin lib/ex_unit/ebin lib/mix/ebin lib/iex/ebin lib/eex/ebin
-	@ echo "==> Dialyzing Elixir..."
-	@ dialyzer --plt .dialyzer_plt -r lib/elixir/ebin lib/ex_unit/ebin lib/mix/ebin lib/iex/ebin lib/eex/ebin
@@ -1,55 +1,94 @@
-![Elixir](https://github.com/elixir-lang/elixir-lang.github.com/raw/master/images/logo/logo.png)
-=========
-[![Build Status](https://secure.travis-ci.org/elixir-lang/elixir.png?branch=master "Build Status")](http://travis-ci.org/elixir-lang/elixir)
+# n8n-openai-adapter

-For more about Elixir, installation and documentation, [check Elixir's website](http://elixir-lang.org/).
+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.

-## Usage
+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.

-If you want to contribute to Elixir or run it from source, clone this repository to your machine, compile and test it:
+## How it works

-    $ git clone https://github.com/elixir-lang/elixir.git
-    $ cd elixir
-    $ make 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":...}}]}
+```

-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.
+Multiple agents = multiple `model` names, each mapped to a different n8n webhook
+in the `AGENTS` env var.

-However, if tests fail, it is likely you have an outdated Erlang version (Elixir requires Erlang R16B or later). You can check your Erlang version by calling `erl` in the command line. You will see some information as follow:
+## Configuration (env vars)

-    Erlang R16B (erts-5.10.1) [source] [64-bit] [smp:2:2] [rq:2] [async-threads:0] [hipe] [kernel-poll:false]
+| 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. |

-If you have the correct version and tests still fail, feel free to [open an issue][2].
+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.

-## Building documentation
+## Admin API (manage agents at runtime)

-Building the documentation requires [ex_doc](https://github.com/elixir-lang/ex_doc) to be installed and built in the same containing folder as elixir.
+Agents are persisted to `AGENTS_FILE` and can be added/removed without a
+redeploy, using the `ADMIN_API_KEY`:

-    # After cloning and compiling Elixir
-    $ git clone git://github.com/elixir-lang/ex_doc.git
-    $ cd ../ex_doc && ../elixir/bin/mix compile
-    $ cd ../elixir && make docs
+```bash
+# list
+curl -H "Authorization: Bearer $ADMIN_API_KEY" https://openai.bueso.eu/admin/agents

-## Contributing
+# 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

-We appreciate any contribution to Elixir, so check out our [CONTRIBUTING.md](CONTRIBUTING.md) guide for more information. We usually keep a list of features and bugs [in the issue tracker][2].
+# remove
+curl -X DELETE -H "Authorization: Bearer $ADMIN_API_KEY" \
+  https://openai.bueso.eu/admin/agents/media-agent
+```

-## Important links
+The store is authoritative and persists across restarts; no env config needed.

-* #elixir-lang on freenode IRC
-* [Website][1]
-* [Issue tracker][2]
-* [elixir-talk Mailing list (questions)][3]
-* [elixir-core Mailing list (development)][4]
+## Building & running

-  [1]: http://elixir-lang.org
-  [2]: https://github.com/elixir-lang/elixir/issues
-  [3]: http://groups.google.com/group/elixir-lang-talk
-  [4]: http://groups.google.com/group/elixir-lang-core
+```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
+```

-## License
+## Testing

-"Elixir" and the Elixir logo are copyright (c) 2012 Plataformatec.
+```bash
+MIX_ENV=test mix test
+```

-Elixir source code is released under Apache 2 License with some parts under Erlang's license (EPL).
+## Nix

-Check LEGAL and LICENSE files for more information.
+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";
+```
@@ -1,27 +0,0 @@
-## Release process
-
-This document simply outlines the release process:
-
-1) Remove `.dev` extension from VERSION
-
-2) Run `make clean test` to ensure all tests pass from scratch and the CI is green
-
-3) Ensure CHANGELOG is updated and tag release version with timestamp in it
-
-4) Commit changes above and update stable branch
-
-5) Create tag from master branch
-
-6) Release new docs with `make release_docs`, update elixir-lang.org
-
-7) Release new zip with `make release_zip`, push new zip to Elixir's elixir-lang.org/packages.html
-
-8) Push package to expm with `expm publish package.exs`
-
-9) After release, bump versions and add `.dev` back
-
-## Places where version is mentioned
-
-* VERSION
-* CHANGELOG
-* src/elixir.app.src
@@ -1 +0,0 @@
-0.9.2
@@ -1,85 +0,0 @@
-#!/bin/sh
-if [ $# -eq 0 ] || [ $1 = "--help" ] || [ $1 = "-h" ]; then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -v                Prints version
-  -e \"command\"      Evaluates the given command (*)
-  -r \"file\"         Requires the given files/patterns (*)
-  -S \"script\"       Finds and executes the given script (*)
-  -pr \"file\"        Requires the given files/patterns in parallel (*)
-  -pa \"path\"        Prepends the given path to Erlang code path (*)
-  -pz \"path\"        Appends the given path to Erlang code path (*)
-  --app \"app\"       Start the given app and its dependencies (*)
-  --erl \"switches\"  Switches to be passed down to erlang (*)
-  --name \"name\"     Makes and assigns a name to the distributed node
-  --sname \"name\"    Makes and assigns a short name to the distributed node
-  --cookie \"cookie\" Sets a cookie for this distributed node
-  --hidden          Makes a hidden node
-  --detached        Starts the Erlang VM detached from console
-  --no-halt         Does not halt the Erlang VM after execution
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTS 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
-}
-
-ERL=""
-I=1
-
-while [ $I -le $# ]; do
-  S=1
-  eval "PEEK=\${$I}"
-  case "$PEEK" in
-    -v|--compile|--no-halt|+iex|+compile)
-        ;;
-    -e|-r|-pr|-pa|-pz|--remsh|-S)
-        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""
-        ;;
-    --erl)
-        I=$(expr $I + 1)
-        eval "VAL=\${$I}"
-        ERL="$ERL "$VAL""
-        ;;
-    *)
-        break
-        ;;
-  esac
-  I=$(expr $I + $S)
-done
-
-SELF=$(readlink_f "$0")
-SCRIPT_PATH=$(dirname "$SELF")
-
-if [ -f "$HOME/.elixirrc" ]; then . "$HOME/.elixirrc"; fi
-if [ "$ELIXIR_NO_CLI" != "1" ]; then ERL="$ERL -s elixir start_cli"; fi
-
-if [ -f "$SCRIPT_PATH/../releases/RELEASES" ] && [ -f "$SCRIPT_PATH/erl" ]
-then
-  exec "$SCRIPT_PATH"/erl -env ERL_LIBS $ERL_LIBS:"$SCRIPT_PATH/../lib" -boot elixir -noshell $ELIXIR_ERL_OPTS $ERL -extra "$@"
-else
-  exec erl -env ERL_LIBS $ERL_LIBS:"$SCRIPT_PATH/../lib" -noshell $ELIXIR_ERL_OPTS $ERL -extra "$@"
-fi
@@ -1,25 +0,0 @@
-@echo off
-set argc=0
-for %%x in (%*) do set /A argc+=1
-if %argc% == 0 (
-  goto documentation
-) else (
-  goto run
-)
-:documentation
-echo Usage: %~nx0 [options] [.exs file] [data]
-echo.
-echo  -v            Prints version and exit
-echo  -e command    Evaluates the given command (*)
-echo  -r command    Requires the given file/pattern (*)
-echo  -pr command   Requires the given file/pattern in parallel (*)
-echo  -pa path      Prepend the given path to Erlang code path (*)
-echo  -pz path      Append the given path to Erlang code path (*)
-echo  --app app     Start the given app and its dependencies (*)
-echo  --no-halt     Do not halt the Erlang VM after execution
-echo.
-echo ** Options marked with (*) can be given more than once
-echo ** Options given after the .exs file or -- are passed down to the executed code
-echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTS
-:run
-erl -env ERL_LIBS %ERL_LIBS%;"%~dp0\..\lib" -noshell %ELIXIR_ERL_OPTS% -s elixir start_cli -extra %*
@@ -1,27 +0,0 @@
-#!/bin/sh
-if [ $# -eq 0 ]; then
-  echo "Usage: `basename $0` [elixir switches] [compiler switches] [.ex files]
-
-  -o               The directory to output compiled files
-  --no-docs        Do not attach documentation to compiled modules
-  --no-debug-info  Do not attach debug info to compiled modules
-  --ignore-module-conflict
-
-** Options given after -- are passed down to the executed code
-** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTS" >&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 +compile "$@"
@@ -1,21 +0,0 @@
-@echo off
-set argc=0
-for %%x in (%*) do set /A argc+=1
-if %argc% == 0 (
-  goto documentation
-) else (
-  goto run
-)
-:documentation
-echo Usage: %~nx0 [elixir switches] [compiler switches] [.ex files]
-echo.
-echo  -o               The directory to output compiled files
-echo  --no-docs        Do not attach documentation to compiled modules
-echo  --no-debug-info  Do not attach debug info to compiled modules
-echo  --ignore-module-conflict
-echo.
-echo ** Options marked with (*) can be given more than once
-echo ** Options given after -- are passed down to the executed code
-echo ** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTS" >&2
-:run
-call "%~dp0\elixir.bat" +compile %*
@@ -1,38 +0,0 @@
-#!/bin/sh
-if [ $# -gt 0 ] && ([ $1 = "--help" ] || [ $1 = "-h" ]); then
-  echo "Usage: `basename $0` [options] [.exs file] [data]
-
-  -v                Prints version
-  -e \"command\"      Evaluates the given command (*)
-  -r \"file\"         Requires the given files/patterns (*)
-  -S \"script\"       Finds and executes the given script (*)
-  -pr \"file\"        Requires the given files/patterns in parallel (*)
-  -pa \"path\"        Prepends the given path to Erlang code path (*)
-  -pz \"path\"        Appends the given path to Erlang code path (*)
-  --app \"app\"       Start the given app and its dependencies (*)
-  --erl \"switches\"  Switches to be passed down to erlang (*)
-  --name \"name\"     Makes and assigns a name to the distributed node
-  --sname \"name\"    Makes and assigns a short name to the distributed node
-  --remsh \"name\"    Connects to a node using a remote shell
-  --dot-iex \"path\"  Overrides default .iex file and uses path instead;
-                    path can be empty, then no file will be loaded
-
-** Options marked with (*) can be given more than once
-** Options given after the .exs file or -- are passed down to the executed code
-** Options can be passed to the erlang runtime using ELIXIR_ERL_OPTS 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")
-ELIXIR_NO_CLI=1 exec "$SCRIPT_PATH"/elixir --no-halt --erl "-user Elixir.IEx.CLI" +iex "$@"
@@ -1,2 +0,0 @@
-@echo off
-call "%~dp0\elixir.bat" +iex --no-halt -e "IEx.start" %*
@@ -1,3 +0,0 @@
-#!/usr/bin/env elixir
-Mix.start
-Mix.CLI.run
@@ -1,2 +0,0 @@
-@echo off
-call "%~dp0\elixir.bat" "%~dp0\mix" %*
@@ -0,0 +1,7 @@
+import Config
+
+import_config "#{config_env()}.exs"
+
+if config_env() == :test do
+  config :logger, level: :warning
+end
@@ -0,0 +1,3 @@
+import Config
+
+# Dev: no special config — all runtime settings come from env vars.
@@ -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.
@@ -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"))
@@ -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
+}
@@ -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;
+    };
+}
@@ -1,203 +0,0 @@
-defexception EEx.SyntaxError, message: nil
-
-defmodule EEx do
-  @moduledoc %B"""
-  EEx stands for Embedded Elixir. It allows you to embed
-  Elixir code inside a string in a robust way:
-
-      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.
-
-  ## 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 a macro, there are no exceptions for this rule.
-  For example, while some template languages would special-
-  case `if` 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:
-
-      EEx.eval_string "<%= @foo %>", assigns: [foo: 1]
-      #=> 1
-
-  In other words, <%= @foo %> is simply translated to:
-
-      <%= Keyword.get assigns, :foo %>
-
-  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
-
-      defmodule Sample do
-        require EEx
-        EEx.function_from_string :def, :sample, "<%= a + b %>", [:a, :b]
-      end
-
-      Sample.sample(1, 2) #=> "3"
-
-  """
-  defmacro function_from_string(kind, name, source, args // [], options // []) do
-    info = [file: __CALLER__.file, line: __CALLER__.line + 1]
-    quote do
-      info = Keyword.merge unquote(info), unquote(options)
-      EEx.function_from_quoted(__MODULE__, unquote(kind), unquote(name),
-        unquote(args), EEx.compile_string(unquote(source), info), info)
-    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, filename, args // [], options // []) do
-    quote do
-      file = unquote(filename)
-      info = Keyword.merge unquote(options), [file: file, line: 1]
-
-      @file file
-      EEx.function_from_quoted(__MODULE__, unquote(kind), unquote(name),
-        unquote(args), EEx.compile_file(file, info), info)
-    end
-  end
-
-  @doc """
-  Get a string `source` and generate a quoted expression
-  that can be evaluated by Elixir or compiled to a function.
-  """
-  def compile_string(source, options // []) do
-    EEx.Compiler.compile(source, options)
-  end
-
-  @doc """
-  Get a `filename` and generate a quoted expression
-  that can be evaluated by Elixir or compiled to a function.
-  """
-  def compile_file(filename, options // []) do
-    options = Keyword.merge options, [file: filename, line: 1]
-    compile_string(File.read!(filename), options)
-  end
-
-  @doc """
-  Get a string `source` and evaluate the values using the `bindings`.
-
-  ## Examples
-
-      EEx.eval_string "foo <%= bar %>", [bar: "baz"]
-      #=> "foo baz"
-
-  """
-  def eval_string(source, bindings // [], options // []) do
-    compiled = compile_string(source, options)
-    do_eval(compiled, bindings, options)
-  end
-
-  @doc """
-  Get a `filename` and evaluate the values using the `bindings`.
-
-  ## Examples
-
-      # sample.ex
-      foo <%= bar %>
-
-      # iex
-      EEx.eval_file "sample.ex", [bar: "baz"]
-      #=> "foo baz"
-
-  """
-  def eval_file(filename, bindings // [], options // []) do
-    options  = Keyword.put options, :file, filename
-    compiled = compile_file(filename, options)
-    do_eval(compiled, bindings, options)
-  end
-
-  ### Helpers
-
-  @doc false
-  def function_from_quoted(module, kind, name, args, source, info) do
-    args  = Enum.map args, fn arg -> { arg, [], nil } end
-    quote = quote do
-      unquote(kind)(unquote(name)(unquote_splicing(args)), do: unquote(source))
-    end
-    Module.eval_quoted module, quote, [], info
-  end
-
-  defp do_eval(compiled, bindings, options) do
-    { result, _ } = Code.eval_quoted(compiled, bindings, options)
-    result
-  end
-end
@@ -1,117 +0,0 @@
-defrecord EEx.State, engine: EEx.SmartEngine, dict: [], file: 'nofile', line: 1, start_line: 1
-
-defmodule EEx.Compiler do
-  @moduledoc false
-
-  @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.
-  """
-  def compile(source, options) do
-    line   = Keyword.get(options, :line, 1)
-    tokens = EEx.Tokenizer.tokenize(source, line)
-    state  = EEx.State.new(options)
-    generate_buffer(tokens, "", [], state)
-  end
-
-  # Generates the buffers by handling each expression from the tokenizer
-
-  defp generate_buffer([{ :text, _line, chars }|t], buffer, scope, state) do
-    buffer = state.engine.handle_text(buffer, chars)
-    generate_buffer(t, buffer, scope, state)
-  end
-
-  defp generate_buffer([{ :expr, line, mark, chars }|t], buffer, scope, state) do
-    expr = maybe_block :elixir_translator.forms!(chars, line, state.file, [])
-    buffer = state.engine.handle_expr(buffer, mark, expr)
-    generate_buffer(t, buffer, scope, state)
-  end
-
-  defp generate_buffer([{ :start_expr, line, mark, chars }|t], buffer, scope, state) do
-    { contents, t } = generate_buffer(t, "", [chars|scope], state.dict([]).line(line).start_line(line))
-    buffer = state.engine.handle_expr(buffer, mark, contents)
-    generate_buffer(t, buffer, scope, state.dict([]))
-  end
-
-  defp generate_buffer([{ :middle_expr, line, _, chars }|t], buffer, [current|scope], state) do
-    { wrapped, state } = wrap_expr(current, line, buffer, chars, state)
-    generate_buffer(t, "", [wrapped|scope], state.line(line))
-  end
-
-  defp generate_buffer([{ :end_expr, line, _, chars }|t], buffer, [current|_], state) do
-    { wrapped, state } = wrap_expr(current, line, buffer, chars, state)
-    tuples = maybe_block :elixir_translator.forms!(wrapped, state.start_line, state.file, [])
-    buffer = insert_quotes(tuples, state.dict)
-    { buffer, t }
-  end
-
-  defp generate_buffer([{ :end_expr, line, _, chars }|_], _buffer, [], _state) do
-    raise EEx.SyntaxError, message: "unexpected token: #{inspect chars} at line #{inspect line}"
-  end
-
-  defp generate_buffer([], buffer, [], _state) do
-    buffer
-  end
-
-  defp generate_buffer([], _buffer, _scope, _state) do
-    raise EEx.SyntaxError, message: "unexpected end of string. expecting a closing <% end %>."
-  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)
-
-    if state.dict == [] and is_empty?(buffer) do
-      { current ++ new_lines ++ chars, state }
-    else
-      key = length(state.dict)
-      placeholder = '__EEX__(' ++ integer_to_list(key) ++ ');'
-      { current ++ placeholder ++ new_lines ++ chars, state.update_dict([{key, buffer}|&1]) }
-    end
-  end
-
-  # Check if the syntax node represents an empty string
-
-  defp is_empty?(bin) when is_binary(bin) do
-    bc(<<c>> inbits bin, not c in [?\s,?\t,?\r,?\n], do: <<c>>) == ""
-  end
-
-  defp is_empty?({ :<>, _, [left, right] }) do
-    is_empty?(left) and is_empty?(right)
-  end
-
-  defp is_empty?(_) do
-    false
-  end
-
-  # Block wrapping
-
-  defp maybe_block([]),    do: nil
-  defp maybe_block([h]),   do: h
-  defp maybe_block(other), do: { :__block__, [], other }
-
-  # Changes placeholder to real expression
-
-  defp insert_quotes({ :__EEX__, _, [key] }, dict) do
-    { ^key, value } = List.keyfind dict, key, 0
-    value
-  end
-
-  defp insert_quotes({ left, line, right }, dict) do
-    { insert_quotes(left, dict), line, insert_quotes(right, dict) }
-  end
-
-  defp insert_quotes({ left, right }, dict) do
-    { insert_quotes(left, dict), insert_quotes(right, dict) }
-  end
-
-  defp insert_quotes(list, dict) when is_list(list) do
-    Enum.map list, insert_quotes(&1, dict)
-  end
-
-  defp insert_quotes(other, _dict) do
-    other
-  end
-end
@@ -1,56 +0,0 @@
-defmodule EEx.Engine do
-  @moduledoc %B"""
-  This is the basic EEx engine that ships with Elixir.
-  An engine needs to implement two functions:
-
-  * `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:
-
-    * `''`
-    * `'='`
-
-    Read `handle_expr/3` below for more information about the markers
-    implemented by default by this engine.
-  """
-
-  @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
-      tmp = unquote(buffer)
-      tmp <> to_binary(unquote(expr))
-    end
-  end
-
-  def handle_expr(buffer, '', expr) do
-    quote do
-      tmp = unquote(buffer)
-      unquote(expr)
-      tmp
-    end
-  end
-
-  def behaviour_info(:callbacks) do
-    [handle_text: 2, handle_expr: 3]
-  end
-end
@@ -1,97 +0,0 @@
-defmodule EEx.TransformerEngine do
-  @moduledoc """
-  An abstract engine that is meant to be used and
-  built upon in other modules. This engine implements
-  the `EEx.Engine` behavior and provides a `transform`
-  overridable directive that allows a developer to
-  customize the expression returned by the engine.
-
-  Check `EEx.AssignsEngine` and `EEx.SmartEngine` for
-  examples of using this module.
-  """
-
-  @doc false
-  defmacro __using__(_) do
-    quote do
-      @behavior EEx.Engine
-
-      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, transform(expr))
-      end
-
-      defp transform({ a, b, c }) do
-        { transform(a), b, transform(c) }
-      end
-
-      defp transform({ a, b }) do
-        { transform(a), transform(b) }
-      end
-
-      defp transform(list) when is_list(list) do
-        lc i inlist list, do: transform(i)
-      end
-
-      defp transform(other) do
-        other
-      end
-
-      defoverridable [transform: 1, handle_expr: 3, handle_text: 2]
-    end
-  end
-end
-
-defmodule EEx.AssignsEngine do
-  @moduledoc """
-  An abstract engine that, when used with the
-  `TransformerEngine`, allows a developer to access
-  assigns using `@` as syntax.
-
-  This engine is included by default on the SmartEngine.
-
-  ## Examples
-
-      defmodule MyEngine do
-        use EEx.TransformerEngine
-        use EEx.AssignsEngine
-      end
-
-      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 when
-  a template, after compiled, may receive different assigns
-  and the developer don't want to recompile it for each
-  variable set.
-  """
-
-  @doc false
-  defmacro __using__(_) do
-    quote unquote: false do
-      defp transform({ :@, line, [{ name, _, atom }] }) when is_atom(name) and is_atom(atom) do
-        quote(do: Keyword.get var!(assigns), unquote(name))
-      end
-
-      defp transform(arg) do
-        super(arg)
-      end
-
-      defoverridable [transform: 1]
-    end
-  end
-end
-
-defmodule EEx.SmartEngine do
-  use EEx.TransformerEngine
-  use EEx.AssignsEngine
-
-  @moduledoc """
-  An engine meant for end-user usage that includes
-  `AssignsEngine` and other conveniences. Read
-  `EEx.AssignsEngine` for examples.
-  """
-end
@@ -1,159 +0,0 @@
-defmodule EEx.Tokenizer do
-  @moduledoc false
-
-  @doc """
-  Tokenizes the given char list or binary.
-  It returns 4 different types of tokens as result:
-
-  * { :text, line, contents }
-  * { :expr, line, marker, contents }
-  * { :start_expr, line, marker, contents }
-  * { :end_expr, line, marker, contents }
-
-  """
-  def tokenize(bin, line) when is_binary(bin) do
-    tokenize(:unicode.characters_to_list(bin), line)
-  end
-
-  def tokenize(list, line) do
-    Enum.reverse(tokenize(list, line, line, [], []))
-  end
-
-  defp tokenize('<%%' ++ t, current_line, line, buffer, acc) do
-    { buffer, new_line, rest } = tokenize_expr t, line, [?%,?<|buffer]
-    tokenize rest, current_line, new_line, [?>,?%|buffer], acc
-  end
-
-  defp tokenize('<%#' ++ t, current_line, line, buffer, acc) do
-    { _, new_line, rest } = tokenize_expr t, line, []
-    tokenize rest, current_line, new_line, buffer, acc
-  end
-
-  defp tokenize('<%' ++ t, current_line, line, buffer, acc) do
-    { marker, t } = retrieve_marker(t)
-    { expr, new_line, rest } = tokenize_expr t, line, []
-
-    token = token_name(expr)
-    acc   = tokenize_text(current_line, buffer, acc)
-    final = { token, line, marker, Enum.reverse(expr) }
-    tokenize rest, new_line, new_line, [], [final | acc]
-  end
-
-  defp tokenize('\n' ++ t, current_line, line, buffer, acc) do
-    tokenize t, current_line, line + 1, [?\n|buffer], acc
-  end
-
-  defp tokenize([h|t], current_line, line, buffer, acc) do
-    tokenize t, current_line, line, [h|buffer], acc
-  end
-
-  defp tokenize([], current_line, _line, buffer, acc) do
-    tokenize_text(current_line, 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 tokenize_expr([?%,?>|t], line, buffer) do
-    { buffer, line, t }
-  end
-
-  defp tokenize_expr('\n' ++ t, line, buffer) do
-    tokenize_expr t, line + 1, [?\n|buffer]
-  end
-
-  defp tokenize_expr([h|t], line, buffer) do
-    tokenize_expr t, line, [h|buffer]
-  end
-
-  defp tokenize_expr([], _line, _buffer) do
-    raise EEx.SyntaxError, message: "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
-
-  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, 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, function do
-      { :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 only_spaces?(string), do: token, else: :expr
-  end
-
-  defp only_spaces?([h|t]) when h in [?\s, ?\t], do: only_spaces?(t)
-  defp only_spaces?(other), do: other == []
-
-  # Tokenize the buffered text by appending
-  # it to the given accumulator.
-
-  defp tokenize_text(_line, [], acc) do
-    acc
-  end
-
-  defp tokenize_text(line, buffer, acc) do
-    [{ :text, line, :unicode.characters_to_binary(Enum.reverse(buffer)) } | acc]
-  end
-end
@@ -1,7 +0,0 @@
-defmodule EEx.Mixfile do
-  use Mix.Project
-
-  def project do
-    [app: :eex, version: System.version]
-  end
-end
@@ -1,22 +0,0 @@
-Code.require_file "../test_helper.exs", __DIR__
-
-defmodule EEx.SmartEngineTest do
-  use ExUnit.Case, async: true
-
-  test "evaluates simple string" do
-    assert_eval "foo bar", "foo bar"
-  end
-
-  test "evaluates with assigns" do
-    assert_eval "1", "<%= @foo %>", assigns: [foo: 1]
-  end
-
-  test "evaluates with loops" do
-    assert_eval "1\n2\n3\n", "<%= lc x inlist [1,2,3] do %><%= x %>\n<% end %>"
-  end
-
-  defp assert_eval(expected, actual, binding // []) do
-    result = EEx.eval_string(actual, binding, file: __FILE__)
-    assert result == expected
-  end
-end
@@ -1,105 +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) == [ { :text, 1, "foo" } ]
-  end
-
-  test "simple strings" do
-    assert T.tokenize("foo", 1) == [ { :text, 1, "foo" } ]
-  end
-
-  test "strings with embedded code" do
-    assert T.tokenize('foo <% bar %>', 1) == [ { :text, 1, "foo " }, { :expr, 1, [], ' bar ' } ]
-  end
-
-  test "strings with embedded equals code" do
-    assert T.tokenize('foo <%= bar %>', 1) == [ { :text, 1, "foo " }, { :expr, 1, '=', ' bar ' } ]
-  end
-
-  test "strings with more than one line" do
-    assert T.tokenize('foo\n<%= bar %>', 1) == [ { :text, 1, "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) == [
-      {:text, 1, "foo "},
-      {:expr, 1, '=', ' bar\n\nbaz '},
-      {:text, 3, "\n"},
-      {:expr, 4, [], ' foo '},
-      {:text, 4, "\n"}
-    ] 
-  end
-
-  test "quotation" do
-    assert T.tokenize('foo <%% true %>', 1) == [
-      { :text, 1, "foo <% true %>" }
-    ]
-  end
-
-  test "quotation with do/end" do
-    assert T.tokenize('foo <%% true do %>bar<%% end %>', 1) == [
-      { :text, 1, "foo <% true do %>bar<% end %>" }
-    ]
-  end
-
-  test "comments" do
-    assert T.tokenize('foo <%# true %>', 1) == [
-      { :text, 1, "foo " }
-    ]
-  end
-
-  test "comments with do/end" do
-    assert T.tokenize('foo <%# true do %>bar<%# end %>', 1) == [
-      { :text, 1, "foo bar" }
-    ]
-  end
-
-  test "strings with embedded do end" do
-    assert T.tokenize('foo <% if true do %>bar<% end %>', 1) == [
-      { :text, 1, "foo " },
-      { :start_expr, 1, '', ' if true do ' },
-      { :text, 1, "bar" },
-      { :end_expr, 1, '', ' end ' }
-    ]
-  end
-
-  test "strings with embedded -> end" do
-    assert T.tokenize('foo <% cond do %><% false -> %>bar<% true -> %>baz<% end %>', 1) == [
-      { :text, 1, "foo " },
-      { :start_expr, 1, '', ' cond do ' },
-      { :middle_expr, 1, '', ' false -> ' },
-      { :text, 1, "bar" },
-      { :middle_expr, 1, '', ' true -> ' },
-      { :text, 1, "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) == [
-      { :text, 1, "foo " },
-      { :start_expr, 1, '', ' if true do ' },
-      { :text, 1, "bar" },
-      { :middle_expr, 1, '', ' else ' },
-      { :text, 1, "baz" },
-      { :end_expr, 1, '', ' end ' }
-    ]
-  end
-
-  test "raise syntax error when there is start mark and no end mark" do
-    assert_raise EEx.SyntaxError, "missing token: %>", fn ->
-      T.tokenize('foo <% :bar', 1)
-    end
-  end
-end
@@ -1,351 +0,0 @@
-Code.require_file "test_helper.exs", __DIR__
-
-require EEx
-
-defmodule EExText.Compiled do
-  def before_compile do
-    fill_in_stacktrace
-    { __ENV__.line, hd(tl(System.stacktrace)) }
-  end
-  { :erlang, 1, 2 }.tuple_to_list
-  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]
-  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
-
-  @file __ENV__
-  def other do
-    fill_in_stacktrace
-    { __ENV__.line, hd(tl(System.stacktrace)) }
-  end
-
-  defp fill_in_stacktrace do
-    try do
-      :erlang.error "failed"
-    catch
-      :error, _, stack -> stack
-    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
-
-  test "evaluates simple string" do
-    assert_eval "foo bar", "foo bar"
-  end
-
-  test "evaluates with embedded" do
-    assert_eval "foo bar", "foo <%= :bar %>"
-  end
-
-  test "evaluates with embedded and the binding" do
-    assert EEx.eval_string("foo <%= bar %>", [bar: 1]) == "foo 1"
-  end
-
-  test "evaluates with embedded do end" do
-    assert_eval "foo bar", "foo <%= if true do %>bar<% end %>"
-  end
-
-  test "evaluates with embedded do end and eval the expression" do
-    assert_eval "foo ", "foo <%= if false do %>bar<% end %>"
-  end
-
-  test "evaluates with embedded do end and nested print expression" do
-    assert_eval "foo bar", "foo <%= if true do %><%= :bar %><% end %>"
-  end
-
-  test "evaluates with embedded do end and nested expressions" do
-    assert_eval "foo bar baz", "foo <%= if true do %>bar <% Process.put(:eex_text, 1) %><%= :baz %><% end %>"
-    assert Process.get(:eex_text) == 1
-  end
-
-  test "evaluates with embedded middle expression" do
-    assert_eval "foo bar", "foo <%= if true do %>bar<% else %>baz<% end %>"
-  end
-
-  test "evaluates with embedded middle expression and eval the expression" do
-    assert_eval "foo baz", "foo <%= if false do %>bar<% else %>baz<% end %>"
-  end
-
-  test "evaluates with nested start expression" do
-    assert_eval "foo bar", "foo <%= if true do %><%= if true do %>bar<% end %><% end %>"
-  end
-
-  test "evaluates with nested middle expression" do
-    assert_eval "foo baz", "foo <%= if true do %><%= if false do %>bar<% else %>baz<% end %><% end %>"
-  end
-
-  test "evaluates with defined variable" do
-    assert_eval "foo 1", "foo <% bar = 1 %><%= bar %>"
-  end
-
-  test "evaluates with require code" do
-    assert_eval "foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1,2,3], \",\" %>"
-  end
-
-  test "evaluates with end of token" do
-    assert_eval "foo bar %>", "foo bar %>"
-  end
-
-  test "raises a syntax error when the token is invalid" do
-    assert_raise EEx.SyntaxError, "missing token: %>", fn ->
-      EEx.compile_string "foo <%= bar"
-    end
-  end
-
-  test "raises a syntax error when end expression is found without a start expression" do
-    assert_raise EEx.SyntaxError, "unexpected token: ' end ' at line 1",  fn ->
-      EEx.compile_string "foo <% end %>"
-    end
-  end
-
-  test "raises a syntax error when start expression is found without an end expression" do
-    assert_raise EEx.SyntaxError, "unexpected end of string. expecting a closing <% end %>.", fn ->
-      EEx.compile_string "foo <% if true do %>"
-    end
-  end
-
-  test "raises a syntax error when nested end expression is found without an start expression" do
-    assert_raise EEx.SyntaxError, "unexpected token: ' end ' at line 1", fn ->
-      EEx.compile_string "foo <% if true do %><% end %><% end %>"
-    end
-  end
-
-  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 "properly handle functions" do
-    expected = """
-
-Number 1
-
-Number 2
-
-Number 3
-
-"""
-
-    string = """
-<%= Enum.map [1,2,3], fn x -> %>
-Number <%= x %>
-<% end %>
-"""
-
-    assert_eval expected, string
-  end
-
-  test "do not consider already finished functions" do
-    expected = """
-foo
-
-true
-
-"""
-
-    string = """
-foo
-<%= cond do %>
-<% false -> %> false
-<% fn -> 1 end -> %>
-<%= true %>
-<% end %>
-"""
-
-    assert_eval expected, string
-  end
-
-  test "unicode" do
-    template = """
-      • <%= "•" %> •
-      <%= "Jößé Vâlìm" %> Jößé Vâlìm
-    """
-    result = EEx.eval_string(template)
-    assert result == "  • • •\n  Jößé Vâlìm Jößé Vâlìm\n"
-  end
-
-  test "evaluates the source from a given file" do
-    filename = Path.join(__DIR__, "fixtures/eex_template.eex")
-    result = EEx.eval_file(filename)
-    assert result == "foo bar.\n"
-  end
-
-  test "evaluates the source from a given file with bindings" do
-    filename = Path.join(__DIR__, "fixtures/eex_template_with_bindings.eex")
-    result = EEx.eval_file(filename, [bar: 1])
-    assert result == "foo 1\n"
-  end
-
-  test "raises an Exception when there's an error with the given file" do
-    assert_raise File.Error, "could not read file non-existent.eex: no such file or directory", fn ->
-      filename = "non-existent.eex"
-      EEx.compile_file(filename)
-    end
-  end
-
-  test "defined from string" do
-    assert EExText.Compiled.string_sample(1, 2) == "3"
-  end
-
-  test "defined from file" do
-    assert EExText.Compiled.file_sample(1) == "foo 1\n"
-  end
-
-  test "defined from file do not affect backtrace" do
-    assert EExText.Compiled.before_compile ==
-      { 8,
-        { EExText.Compiled,
-          :before_compile,
-          0,
-          [file: binary_to_list(__FILE__), line: 7]
-        }
-      }
-
-    assert EExText.Compiled.after_compile ==
-      { 19,
-        { EExText.Compiled,
-          :after_compile,
-          0,
-          [file: binary_to_list(__FILE__), line: 18]
-        }
-      }
-
-    assert EExText.Compiled.unknown ==
-      { 25,
-        { EExText.Compiled,
-          :unknown,
-          0,
-          [file: 'unknown', line: 24]
-        }
-      }
-
-    assert EExText.Compiled.other ==
-      { 31,
-        { EExText.Compiled,
-          :other,
-          0,
-          [file: binary_to_list(__FILE__), line: 30]
-        }
-      }
-  end
-
-  defp assert_eval(expected, actual) do
-    result = EEx.eval_string(actual, [], file: __FILE__, engine: EEx.Engine)
-    assert result == expected
-  end
-end
@@ -1 +0,0 @@
-foo <%= if true do %>bar.<% end %>
@@ -1 +0,0 @@
-foo <%= bar %>
@@ -1 +0,0 @@
-ExUnit.start []
@@ -1,76 +0,0 @@
-define(wrap_call(Line, Module, Function, Args),
-  { call, Line,
-    { remote, Line, { atom, Line, Module }, { atom, Line, Function } },
-    Args
-  }).
-
-define(atom_concat(Atoms), list_to_atom(lists:concat(Atoms))).
-define(elixir_macro(Macro), list_to_atom(lists:concat(['MACRO-',Macro]))).
-define(line(Opts), elixir_tree_helpers:get_line(Opts)).
-
-record(elixir_scope, {
-  context=nil,             %% can be assign, guards or nil
-  noname=false,            %% when true, don't add new names (used by try)
-  super=false,             %% when true, it means super was invoked
-  caller=false,            %% when true, it means caller was invoked
-  name_args=false,         %% when true, it means arguments should be named
-  module=nil,              %% the current module
-  function=nil,            %% the current function
-  vars=[],                 %% a dict of defined variables and their alias
-  temp_vars=[],            %% a dict of all variables defined in a particular assign
-  clause_vars=nil,         %% a dict of all variables defined in a particular clause
-  extra_guards=nil,        %% extra guards from args expansion
-  counter=[],              %% a counter for the variables defined
-  local=nil,               %% the scope to evaluate local functions against
-  context_modules=[],      %% modules defined in the current context
-  macro_aliases=[],        %% keep aliases defined inside a macro
-  aliases,                 %% an orddict with aliases by new -> old names
-  file,                    %% the current scope filename
-  requires,                %% a set with modules required
-  macro_macros=[],         %% a list with macros imported from module inside a macro
-  macros,                  %% a list with macros imported from module
-  macro_functions=[],      %% a list with functions imported from module inside a macro
-  functions                %% a list with functions imported from module
-}).
-
-record(elixir_quote, {
-  line=0,
-  context=nil,
-  vars_hygiene=true,
-  aliases_hygiene=true,
-  imports_hygiene=true,
-  unquote=true,
-  unquoted=false,
-  mark=true
-}).
-
-%% Introspection
-define(defs(Kind), Kind == def; Kind == defp; Kind == defmacro; Kind == defmacrop).
-
-%% Used in tokenization and interpolation
-
-%% Numbers
-define(is_hex(S), ?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f)).
-define(is_bin(S), S >= $0 andalso S =< $1).
-define(is_octal(S), S >= $0 andalso S =< $7).
-define(is_leading_octal(S), S >= $0 andalso S =< $3).
-
-%% Digits and letters
-define(is_digit(S), S >= $0 andalso S =< $9).
-define(is_upcase(S), S >= $A andalso S =< $Z).
-define(is_downcase(S), S >= $a andalso S =< $z).
-
-%% Atoms
-define(is_new_atom(S), ?is_quote(S) orelse ?is_upcase(S) orelse ?is_downcase(S) orelse (S == $_)).
-define(is_atom(S), ?is_identifier(S) orelse (S == $@)).
-
-define(is_identifier(S), ?is_digit(S) orelse ?is_upcase(S) orelse ?is_downcase(S) orelse (S == $_)).
-define(is_terminator(S), (S == $?) orelse (S == $!) orelse (S == $:)).
-
-%% Quotes
-define(is_quote(S), S == $" orelse S == $').
-
-%% Spaces
-define(is_horizontal_space(S), (S == $\s) orelse (S == $\t)).
-define(is_vertical_space(S), (S == $\r) orelse (S == $\n)).
-define(is_space(S), ?is_horizontal_space(S) orelse ?is_vertical_space(S)).
@@ -1,61 +0,0 @@
-import Kernel, except: [access: 2]
-
-defprotocol Access do
-  @moduledoc """
-  The Access protocol is the underlying protocol invoked
-  when the brackets syntax is used. For instance, `foo[bar]`
-  is translated to `access foo, bar` which, by default,
-  invokes the `Access.access` protocol.
-
-  This protocol is limited and is implemented only for the
-  following built-in types: keywords, records and functions.
-  """
-
-  @only [List, Record, Atom]
-
-  @doc """
-  Receives the element being accessed and the access item.
-  """
-  def access(container, key)
-end
-
-defimpl Access, for: List do
-  @doc """
-  Access the given key in a tuple list.
-
-  ## Examples
-
-      iex> keywords = [a: 1, b: 2]
-      ...> keywords[:a]
-      1
-
-      iex> star_ratings = [{1.0, "★"}, {1.5, "★☆"}, {2.0, "★★"}]
-      ...> star_ratings[1.5]
-      "★☆"
-
-  """
-  def access([], _key), do: nil
-
-  def access(list, key) do
-    case :lists.keyfind(key, 1, list) do
-      { ^key, value } -> value
-      false -> nil
-    end
-  end
-end
-
-defimpl Access, for: Atom do
-  @doc """
-  The access protocol can only be accessed by atoms
-  at compilation time. If we reach this, we should raise
-  an exception.
-  """
-  def access(nil, _) do
-    nil
-  end
-
-  def access(atom, _) do
-    raise "The access protocol can only be invoked for atoms at " <>
-      "compilation time, tried to invoke it for #{inspect atom}"
-  end
-end
@@ -1,105 +0,0 @@
-defmodule Application.Behaviour do
-  @moduledoc """
-  This module is a convenience to define application module callbacks.
-
-  In Erlang/OTP, an application is a component that can be started
-  and stopped as a unit, and which can be re-used in other systems
-  as well.
-
-  The first step to achieve this is to define an application specification.
-  For example, if your application is named `:my_app`, an app specification
-  should exist at `ebin/my_app.app`. This file is usually defined by
-  build tools like Mix.
-
-  Then, with the app specification in hands, we must also define an
-  application module callback that controls how to start and stop
-  such applications. This module is about defining such callbacks.
-
-  There are two callbacks required to be implemented:
-
-  1. `start(type, args)` - It must return `{ :ok, pid }` or
-     `{ :ok, pid, state }`, where `pid` is the process identifier
-     of the supervisor tree root;
-
-  2. `stop(state)` receives the state returned by `start` and should
-     do any necessary cleaning up. Notice that shutting down the supervisor
-     is automatically handled by the VM;
-
-  When using this module, it simply tags the module behaviour as
-  `:application` and defines a default `stop/1` callback. The `start/2`
-  still needs to be defined by the user.
-
-  You can learn more about the `:application` module, the application
-  specification and the application module callbacks below:
-
-  http://www.erlang.org/doc/man/application.html
-  http://www.erlang.org/doc/design_principles/applications.html
-  http://learnyousomeerlang.com/building-otp-applications
-
-  ## Example
-
-      defmodule MyApp do
-        use Application.Behaviour
-
-        def start(_type, args) do
-          MyApp.Sup.start_link(args)
-        end
-      end
-
-  """
-
-  # Starts the given application and all of its dependencies that
-  # have not been started yet recursively.
-  #
-  # ## Supported types
-  #
-  # When starting an application, a type can be given:
-  #
-  # * `:permanent` - If a permanent application terminates, all other
-  #    applications and the runtime system are also terminated;
-  # * `:transient` - If a transient application terminates with reason
-  #    `:normal`, this is reported but no other applications are terminated.
-  #    If a transient application terminates abnormally, all other
-  #    applications and the runtime system are also terminated;
-  # * `:temporary` -  If a temporary application terminates, this is reported
-  #    but no other applications are terminated.
-  #
-  # The type only applies to the application being started. Its dependencies
-  # are all started with default type (which is :temporary).
-  #
-  # Note that transient mode is of little practical use, since when a
-  # supervision tree terminates, the reason is set to shutdown, not normal.
-  #
-  # ## Examples
-  #
-  #     Application.Behaviour.start(:my_app)
-  #
-  @doc false
-  def start(app, type // :temporary) do
-    case :application.start(app, type) do
-      { :error, { :not_started, dep } } ->
-        case start(dep) do
-          :ok   -> start(app, type)
-          other -> other
-        end
-      { :error, { :already_started, _ } } ->
-        :ok
-      other ->
-        other
-    end
-  end
-
-  @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behavior :application
-
-      @doc false
-      def stop(_state) do
-        :ok
-      end
-
-      defoverridable [stop: 1]
-    end
-  end
-end
@@ -1,116 +0,0 @@
-defmodule Behaviour do
-  @moduledoc """
-  A convenience module for defining behaviours.
-  Behaviours can be referenced by other modules
-  in order to ensure they implement the proper
-  callbacks.
-
-  For example, you can specify the `URI.Parser`
-  behaviour as follow:
-
-      defmodule URI.Parser do
-        use Behaviour
-
-        @doc "Parses the given URL"
-        defcallback parse(uri_info :: URI.Info.t) :: URI.Info.t
-
-        @doc "Defines a default port"
-        defcallback default_port() :: integer
-      end
-
-  And then a specific module may use it as:
-
-      defmodule URI.HTTP do
-        @behaviour URI.Parser
-        def default_port(), do: 80
-        def parse(info), do: info
-      end
-
-  In case the behaviour changes or URI.HTTP does
-  not implement one of the callbacks, a warning
-  will be raised.
-
-  ## Implementation
-
-  Behaviours since Erlang R15 must be defined via
-  `@callback` attributes. `defcallback` is a simple
-  mechanism that defines the `@callback` attribute
-  according to the type specification and also allows
-  docs and defines a custom function signature.
-
-  The callbacks and their documentation can be retrieved
-  via the `__behaviour__` callback function.
-  """
-
-  @doc """
-  Defines a callback according to the given type specification.
-  """
-  defmacro defcallback({ :::, _, [fun, return] }) do
-    do_defcallback(fun, return, __CALLER__)
-  end
-
-  defmacro defcallback(fun) do
-    do_defcallback(fun, quote(do: term), __CALLER__)
-  end
-
-  defp do_defcallback(fun, return, caller) do
-    case Macro.extract_args(fun) do
-      { name, args } -> :ok
-      :error ->
-        raise ArgumentError, message: "invalid syntax in defcallback #{Macro.to_binary(fun)}"
-    end
-
-    arity = length(args)
-
-    Enum.each args, fn
-      { :::, _, [left, right] } ->
-        ensure_not_default(left)
-        ensure_not_default(right)
-        left
-      other ->
-        ensure_not_default(other)
-        other
-    end
-
-    quote do
-      @callback unquote(name)(unquote_splicing(args)) :: unquote(return)
-      Behaviour.store_docs __MODULE__, unquote(caller.line), unquote(name), unquote(arity)
-    end
-  end
-
-  defp ensure_not_default({ ://, _, [_, _] }) do
-    raise ArgumentError, message: "default arguments // not supported in defcallback"
-  end
-
-  defp ensure_not_default(_), do: :ok
-
-  @doc false
-  def store_docs(module, line, name, arity) do
-    doc = Module.get_attribute module, :doc
-    Module.delete_attribute module, :doc
-    Module.put_attribute module, :__behaviour_docs, { { name, arity }, line, doc }
-  end
-
-  @doc false
-  defmacro __using__(_) do
-    quote do
-      Module.register_attribute(__MODULE__, :__behaviour_docs, accumulate: true)
-      @before_compile unquote(__MODULE__)
-      import unquote(__MODULE__)
-    end
-  end
-
-  @doc false
-  defmacro __before_compile__(_) do
-    quote do
-      @doc false
-      def __behaviour__(:callbacks) do
-        __MODULE__.behaviour_info(:callbacks)
-      end
-
-      def __behaviour__(:docs) do
-        @__behaviour_docs
-      end
-    end
-  end
-end
@@ -1,92 +0,0 @@
-import Kernel, except: [to_binary: 1]
-
-defprotocol Binary.Chars do
-  @moduledoc %B"""
-  The Binary.Chars protocol is responsible for
-  converting a structure to a Binary (only if applicable).
-  The only function required to be implemented is
-  `to_binary` which does the conversion.
-
-  The `to_binary` function automatically imported
-  by Kernel invokes this protocol. String
-  interpolation also invokes to_binary in its
-  arguments. For example, `"foo#{bar}"` is the same
-  as `"foo" <> to_binary(bar)`.
-  """
-
-  @only [BitString, List, Number, Atom, Record]
-
-  def to_binary(thing)
-end
-
-defimpl Binary.Chars, for: Atom do
-  @doc """
-  Convert the atom literally to a binary, except
-  `nil` which is converted to an empty string.
-  """
-  def to_binary(nil) do
-    ""
-  end
-
-  def to_binary(atom) do
-    atom_to_binary(atom, :utf8)
-  end
-end
-
-defimpl Binary.Chars, for: BitString do
-  @doc """
-  Simply returns the binary itself.
-  """
-  def to_binary(thing) when is_binary(thing) do
-    thing
-  end
-end
-
-defimpl Binary.Chars, for: List do
-  @doc """
-  Consider the list is an iolist and converts it
-  to a binary. This allows a list of binaries, or
-  a charlist, or a mix of both, to be converted
-  successfully.
-
-  ## Examples
-
-      iex> to_binary('foo')
-      "foo"
-      iex> to_binary(["foo", 'bar'])
-      "foobar"
-
-  """
-  def to_binary(thing) do
-    try do
-      iolist_to_binary(thing)
-    rescue
-      ArgumentError ->
-        raise Protocol.UndefinedError,
-                 protocol: __MODULE__,
-                structure: thing,
-                    extra: "Only iolists are supported"
-    end
-  end
-end
-
-defimpl Binary.Chars, for: Number do
-  @doc """
-  Simply converts the number (integer or a float) to a binary.
-  """
-
-  @digits 20
-  @limit  :math.pow(10, @digits)
-
-  def to_binary(thing) when is_integer(thing) do
-    integer_to_binary(thing)
-  end
-
-  def to_binary(thing) when thing > @limit do
-    float_to_binary(thing, scientific: @digits)
-  end
-
-  def to_binary(thing) do
-    float_to_binary(thing, compact: true, decimals: @digits)
-  end
-end
@@ -1,462 +0,0 @@
-import Kernel, except: [inspect: 1]
-
-defprotocol Binary.Inspect do
-  @moduledoc """
-  The `Binary.Inspect` protocol is responsible for
-  converting any structure to a binary for textual
-  representation. All basic data structures
-  (tuple, list, function, pid, etc) implement the
-  inspect protocol. Other structures are advised to
-  implement the protocol in order to provide pretty
-  printing.
-  """
-
-  def inspect(thing, opts)
-end
-
-defmodule Binary.Inspect.Utils do
-  @moduledoc false
-
-  ## container_join
-
-  def container_join(tuple, first, last, opts) when is_tuple(tuple) do
-    container_join(tuple_to_list(tuple), first, last, opts)
-  end
-
-  def container_join(list, first, last, opts) do
-    first <> do_container_join(list, opts, Keyword.get(opts, :limit, :infinity)) <> last
-  end
-
-  defp do_container_join(_, _opts, 0) do
-    "..."
-  end
-
-  defp do_container_join([h], opts, _counter) do
-    Kernel.inspect(h, opts)
-  end
-
-  defp do_container_join([h|t], opts, counter) when is_list(t) do
-    Kernel.inspect(h, opts) <> "," <> do_container_join(t, opts, decrement(counter))
-  end
-
-  defp do_container_join([h|t], opts, _counter) do
-    Kernel.inspect(h, opts) <> "|" <> Kernel.inspect(t, opts)
-  end
-
-  defp do_container_join([], _opts, _counter) do
-    ""
-  end
-
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
-
-  ## escape
-
-  def escape(other, char) do
-    b = do_escape(other, char, <<>>)
-    << char, b :: binary, char >>
-  end
-
-  @compile {:inline, do_escape: 3}
-  defp do_escape(<<>>, _char, binary), do: binary
-  defp do_escape(<< char, t :: binary >>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, char >>)
-  end
-  defp do_escape(<<?#, ?{, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?#, ?{ >>)
-  end
-  defp do_escape(<<?\a, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?a >>)
-  end
-  defp do_escape(<<?\b, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?b >>)
-  end
-  defp do_escape(<<?\d, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?d >>)
-  end
-  defp do_escape(<<?\e, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?e >>)
-  end
-  defp do_escape(<<?\f, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?f >>)
-  end
-  defp do_escape(<<?\n, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?n >>)
-  end
-  defp do_escape(<<?\r, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?r >>)
-  end
-  defp do_escape(<<?\\, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?\\ >>)
-  end
-  defp do_escape(<<?\t, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?t >>)
-  end
-  defp do_escape(<<?\v, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, ?\\, ?v >>)
-  end
-  defp do_escape(<<h, t :: binary>>, char, binary) do
-    do_escape(t, char, << binary :: binary, h >>)
-  end
-end
-
-defimpl Binary.Inspect, for: Atom do
-  require Macro
-  import Binary.Inspect.Utils
-
-  @moduledoc """
-  Represents the atom as an Elixir term. The atoms false, true
-  and nil are simply quoted. Modules are properly represented
-  as modules using the dot notation.
-
-  Notice that in Elixir, all operators can be represented using
-  literal atoms (`:+`, `:-`, etc).
-
-  ## Examples
-
-      iex> inspect(:foo)
-      ":foo"
-      iex> inspect(nil)
-      "nil"
-      iex> inspect(Foo.Bar)
-      "Foo.Bar"
-
-  """
-
-  def inspect(false, _),  do: "false"
-  def inspect(true, _),   do: "true"
-  def inspect(nil, _),    do: "nil"
-  def inspect(:"", _),    do: ":\"\""
-  def inspect(Elixir, _), do: "Elixir"
-
-  def inspect(atom, _) do
-    binary = atom_to_binary(atom)
-
-    cond do
-      valid_atom_identifier?(binary) ->
-        ":" <> binary
-      valid_ref_identifier?(binary) ->
-        Module.to_binary(atom)
-      atom in Macro.binary_ops or atom in Macro.unary_ops ->
-        ":" <> binary
-      true ->
-        ":" <> escape(binary, ?")
-    end
-  end
-
-  # Detect if atom is an atom alias (Elixir.Foo.Bar.Baz)
-
-  defp valid_ref_identifier?("Elixir" <> rest) do
-    valid_ref_piece?(rest)
-  end
-
-  defp valid_ref_identifier?(_), do: false
-
-  defp valid_ref_piece?(<<?., h, t :: binary>>) when h in ?A..?Z do
-    valid_ref_piece? valid_identifier?(t)
-  end
-
-  defp valid_ref_piece?(<<>>), do: true
-  defp valid_ref_piece?(_),    do: false
-
-  # Detect if atom
-
-  defp valid_atom_identifier?(<<h, t :: binary>>) when h in ?a..?z or h in ?A..?Z or h == ?_ do
-    case valid_identifier?(t) do
-      <<>>   -> true
-      <<??>> -> true
-      <<?!>> -> true
-      _      -> false
-    end
-  end
-
-  defp valid_atom_identifier?(_), do: false
-
-  defp valid_identifier?(<<h, t :: binary>>)
-      when h in ?a..?z
-      when h in ?A..?Z
-      when h in ?0..?9
-      when h == ?_ do
-    valid_identifier? t
-  end
-
-  defp valid_identifier?(other), do: other
-end
-
-defimpl Binary.Inspect, for: BitString do
-  import Binary.Inspect.Utils
-
-  @moduledoc %B"""
-  Represents the string as itself escaping
-  all necessary characters.
-
-  ## Examples
-
-      iex> inspect("bar")
-      "\"bar\""
-      iex> inspect("f\"oo")
-      "\"f\\\"oo\""
-
-  """
-
-  def inspect(thing, opts) when is_binary(thing) do
-    if String.printable?(thing) do
-      escape(thing, ?")
-    else
-      as_bitstring(thing, opts)
-    end
-  end
-
-  def inspect(thing, opts) do
-    as_bitstring(thing, opts)
-  end
-
-  ## Bitstrings
-
-  defp as_bitstring(bitstring, opts) do
-    "<<" <> each_bit(bitstring, Keyword.get(opts, :limit, :infinity)) <> ">>"
-  end
-
-  defp each_bit(_, 0) do
-    "..."
-  end
-
-  defp each_bit(<<h, t :: bitstring>>, counter) when t != <<>> do
-    integer_to_binary(h) <> "," <> each_bit(t, decrement(counter))
-  end
-
-  defp each_bit(<<h :: size(8)>>, _counter) do
-    integer_to_binary(h)
-  end
-
-  defp each_bit(<<>>, _counter) do
-    <<>>
-  end
-
-  defp each_bit(bitstring, _counter) do
-    size = bit_size(bitstring)
-    <<h :: size(size)>> = bitstring
-    integer_to_binary(h) <> "::size(" <> integer_to_binary(size) <> ")"
-  end
-
-  defp decrement(:infinity), do: :infinity
-  defp decrement(counter),   do: counter - 1
-end
-
-defimpl Binary.Inspect, for: List do
-  import Binary.Inspect.Utils
-
-  @moduledoc %B"""
-  Represents a list checking if it can be printed or not.
-  If so, a single-quoted representation is returned,
-  otherwise the brackets syntax is used.
-
-  Inspecting a list is conservative as it does not try
-  to guess how the list is encoded. That said, `'josé'`
-  will likely be inspected as `[106,111,115,195,169]`
-  because we can't know if it is encoded in utf-8
-  or iso-5569-1, which is common in Erlang libraries.
-
-  ## Examples
-
-      iex> inspect('bar')
-      "'bar'"
-      iex> inspect([0|'bar'])
-      "[0,98,97,114]"
-      iex> inspect([:foo,:bar])
-      "[:foo,:bar]"
-
-  """
-
-  def inspect([], _), do: "[]"
-
-  def inspect(thing, opts) do
-    cond do
-      :io_lib.printable_list(thing) ->
-        escape(:unicode.characters_to_binary(thing), ?')
-      keyword?(thing) ->
-        "[" <> join_keywords(thing, opts) <> "]"
-      true ->
-        container_join(thing, "[", "]", opts)
-    end
-  end
-
-  defp join_keywords(thing, opts) do
-    Enum.join(lc {key, value} inlist thing do
-      key_to_binary(key, opts) <> ": " <> Kernel.inspect(value, opts)
-    end, ", ")
-  end
-
-  defp key_to_binary(key, opts) do
-    case Binary.Inspect.Atom.inspect(key, opts) do
-      ":" <> right -> right
-      other -> other
-    end
-  end
-
-  defp keyword?([{ key, _value } | rest]) when is_atom(key) do
-    case atom_to_list(key) do
-      'Elixir.' ++ _ -> false
-      _ -> keyword?(rest)
-    end
-  end
-
-  defp keyword?([]),     do: true
-  defp keyword?(_other), do: false
-end
-
-defimpl Binary.Inspect, for: Tuple do
-  import Binary.Inspect.Utils
-
-  @moduledoc """
-  Inspect tuples. If the tuple represents a record,
-  it shows it nicely formatted using the access syntax.
-
-  ## Examples
-
-      iex> inspect({1,2,3})
-      "{1,2,3}"
-      iex> inspect(ArgumentError.new)
-      "ArgumentError[message: \\\"argument error\\\"]"
-
-  """
-
-  def inspect({}, _), do: "{}"
-
-  def inspect(tuple, opts) do
-    unless opts[:raw] do
-      record_inspect(tuple, opts)
-    end || container_join(tuple, "{", "}", opts)
-  end
-
-  ## Helpers
-
-  defp record_inspect(record, opts) do
-    list = tuple_to_list(record)
-    [name|tail] = list
-
-    if (fields = record_fields(name)) && (length(fields) == size(record) - 1) do
-      if Enum.first(tail) == :__exception__ do
-        record_join(name, tl(fields), tl(tail), opts)
-      else
-        record_join(name, fields, tail, opts)
-      end
-    end
-  end
-
-  defp record_fields(name) do
-    try do
-      name.__record__(:fields)
-    rescue
-      _ -> nil
-    end
-  end
-
-  defp record_join(name, fields, tail, opts) do
-    fields = lc { field, _ } inlist fields, do: field
-    Binary.Inspect.Atom.inspect(name, opts) <> "[" <>
-      record_join(fields, tail, opts) <> "]"
-  end
-
-  defp record_join([f], [v], opts) do
-    atom_to_binary(f, :utf8) <> ": " <> Kernel.inspect(v, opts)
-  end
-
-  defp record_join([fh|ft], [vh|vt], opts) do
-    atom_to_binary(fh, :utf8) <> ": " <>
-      Kernel.inspect(vh, opts) <> ", " <>
-      record_join(ft, vt, opts)
-  end
-
-  defp record_join([], [], _opts) do
-    ""
-  end
-end
-
-defimpl Binary.Inspect, for: Number do
-  @moduledoc """
-  Represents the number as a binary.
-
-  ## Examples
-
-      iex> inspect(1)
-      "1"
-
-  """
-
-  @digits 20
-  @limit  :math.pow(10, @digits)
-
-  def inspect(thing, _) when is_integer(thing) do
-    integer_to_binary(thing)
-  end
-
-  def inspect(thing, _) when thing > @limit do
-    float_to_binary(thing, scientific: @digits)
-  end
-
-  def inspect(thing, _) do
-    float_to_binary(thing, compact: true, decimals: @digits)
-  end
-end
-
-defimpl Binary.Inspect, for: Regex do
-  @moduledoc %B"""
-  Represents the Regex using the `%r""` syntax.
-
-  ## Examples
-
-      iex> inspect(%r/foo/m)
-      "%r\"foo\"m"
-
-  """
-
-  def inspect(regex, _opts) when size(regex) == 5 do
-    "%r" <> Kernel.inspect(Regex.source(regex), []) <> Regex.opts(regex)
-  end
-
-  def inspect(other, opts) do
-    Kernel.inspect other, Keyword.put(opts, :raw, true)
-  end
-end
-
-defimpl Binary.Inspect, for: Function do
-  @moduledoc """
-  Inspect functions, when possible, in a literal form.
-  """
-
-  def inspect(function, _opts) do
-    fun_info = :erlang.fun_info(function)
-    if fun_info[:type] == :external and fun_info[:env] == [] do
-      "function(#{Kernel.inspect(fun_info[:module])}.#{fun_info[:name]}/#{fun_info[:arity]})"
-    else
-      '#Fun' ++ rest = :erlang.fun_to_list(function)
-      "#Function" <> list_to_binary(rest)
-    end
-  end
-end
-
-defimpl Binary.Inspect, for: PID do
-  @moduledoc "Inspect PIDs"
-
-  def inspect(pid, _) do
-    "#PID" <> list_to_binary pid_to_list(pid)
-  end
-end
-
-defimpl Binary.Inspect, for: Port do
-  @moduledoc "Inspect ports"
-
-  def inspect(port, _) do
-    list_to_binary :erlang.port_to_list(port)
-  end
-end
-
-defimpl Binary.Inspect, for: Reference do
-  @moduledoc "Inspect references"
-
-  def inspect(ref, _) do
-    '#Ref' ++ rest = :erlang.ref_to_list(ref)
-    "#Reference" <> list_to_binary(rest)
-  end
-end
@@ -1,128 +0,0 @@
-defmodule Bitwise do
-  @moduledoc """
-  This module provide macros and operators for bitwise operators.
-  These macros can be used in guards.
-
-  The easiest way to use is to simply import them into
-  your module:
-
-      iex> use Bitwise
-      iex> bnot 1
-      -2
-      iex> 1 &&& 1
-      1
-
-  You can select to include only or skip operators by passing options:
-
-      iex> use Bitwise, only_operators: true
-      ...> 1 &&& 1
-      1
-
-  """
-
-  @doc """
-  Allow a developer to use this module in their programs with
-  the following options:
-
-  * `:only_operators` - Include only operators;
-  * `:skip_operators` - Skip operators;
-
-  """
-  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 """
-  Bitwise not.
-  """
-  defmacro bnot(expr) do
-    quote do: __op__ :bnot, unquote(expr)
-  end
-
-  @doc """
-  Bitwise not as operator.
-  """
-  defmacro ~~~expr do
-    quote do: __op__ :bnot, unquote(expr)
-  end
-
-  @doc """
-  Bitwise and.
-  """
-  defmacro band(left, right) do
-    quote do: __op__ :band, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Bitwise and as operator.
-  """
-  defmacro left &&& right do
-    quote do: __op__ :band, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Bitwise or.
-  """
-  defmacro bor(left, right) do
-    quote do: __op__ :bor, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Bitwise or as operator.
-  """
-  defmacro left ||| right do
-    quote do: __op__ :bor, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Bitwise xor.
-  """
-  defmacro bxor(left, right) do
-    quote do: __op__ :bxor, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Bitwise xor as operator.
-  """
-  defmacro left ^^^ right do
-    quote do: __op__ :bxor, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Arithmetic bitshift left.
-  """
-  defmacro bsl(left, right) do
-    quote do: __op__ :bsl, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Arithmetic bitshift left as operator.
-  """
-  defmacro left <<< right do
-    quote do: __op__ :bsl, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Arithmetic bitshift right.
-  """
-  defmacro bsr(left, right) do
-    quote do: __op__ :bsr, unquote(left), unquote(right)
-  end
-
-  @doc """
-  Arithmetic bitshift right as operator.
-  """
-  defmacro left >>> right do
-    quote do: __op__ :bsr, unquote(left), unquote(right)
-  end
-end
@@ -1,392 +0,0 @@
-defmodule Code do
-  defexception LoadError, file: nil do
-    def message(exception) do
-      "could not load #{exception.file}"
-    end
-  end
-
-  @moduledoc """
-  The Code module is responsible to manage code compilation,
-  code evaluation and code loading.
-
-  It complements (Erlang's code module)[1] to add behavior
-  which is specific to Elixir.
-
-    [1]: (www.erlang.org/doc/man/code.html)
-
-  """
-
-  @doc """
-  Returns all the loaded files.
-  """
-  def loaded_files do
-    :elixir_code_server.call :loaded
-  end
-
-  @doc """
-  Removes the given files from the loaded files list.
-  The modules defined in the file are not removed,
-  calling this function only removes it from the list,
-  allowing it to be required again.
-  """
-  def unload_files(files) do
-    :elixir_code_server.cast { :unload_files, files }
-  end
-
-  @doc """
-  Appends a path to Erlang VM code path.
-  The path is expanded with `Path.expand` before added.
-  """
-  def append_path(path) do
-    :code.add_pathz(Path.expand to_char_list(path))
-  end
-
-  @doc """
-  Prepends a path to Erlang VM code path.
-  The path is expanded with `Path.expand` before added.
-  """
-  def prepend_path(path) do
-    :code.add_patha(Path.expand to_char_list(path))
-  end
-
-  @doc """
-  Deletes a path from Erlang VM code path.
-  The path is expanded with `Path.expand` before deleted.
-  """
-  def delete_path(path) do
-    :code.del_path(Path.expand to_char_list(path))
-  end
-
-  @doc """
-  Evaluates the contents given by string. The second argument is the
-  binding (which should be a keyword) followed by a keyword list of
-  environment options. Those options can be:
-
-  * `:file` - the file to be considered in the evaluation
-  * `:line` - the line the script starts
-  * `:delegate_locals_to` - delegate local calls to the given module,
-    the default is to not delegate
-
-  Besides, 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
-  * `:macros` - a list of tuples where the first element is a module
-    and the second a list of imported macro names and arity
-
-  Notice that setting any ov the values above overrides Elixir default
-  values. For example, setting `:requires` to `[]`, will no longer
-  automatically required the `Kernel` module, in the same way setting
-  `:macros` will no longer auto-import `Kernel` macros as `if`, `case`,
-  etc.
-
-  ## Examples
-
-      iex> Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      { 3, [ {:a, 1}, {:b, 2} ] }
-
-  For convenience, you can my pass `__ENV__` as argument and
-  all imports, requires and aliases 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
-    eval_string(string, binding, env.to_keywords)
-  end
-
-  def eval_string(string, binding, opts) do
-    { value, binding, _scope } =
-      :elixir.eval :unicode.characters_to_list(string), binding, opts
-    { value, binding }
-  end
-
-  @doc """
-  Evaluates the quoted contents.
-
-  This function accepts a list of environment options.
-  Check `Code.eval_string` for more information.
-
-  ## Examples
-
-      iex> contents = quote(hygiene: [vars: false], do: a + b)
-      ...> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
-      { 3, [ {:a, 1}, {:b, 2} ] }
-
-  For convenience, you can my pass `__ENV__` as argument and
-  all options will be automatically extracted from the environment:
-
-      iex> contents = quote(hygiene: [vars: false], do: a + b)
-      ...> 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
-    eval_quoted(quoted, binding, env.to_keywords)
-  end
-
-  def eval_quoted(quoted, binding, opts) do
-    { value, binding, _scope } =
-      :elixir.eval_quoted [quoted], binding, opts
-    { value, binding }
-  end
-
-  @doc """
-  Converts the given string to AST. It returns `{ :ok, ast }`
-  if it succeeds, `{ :error, { line, error, token } }` otherwise.
-
-  ## Options
-
-  * `:file` - The filename to be used in stacktraces
-    and the file reported in the __ENV__ variable.
-
-  * `:line` - The line reported in the __ENV__ variable.
-
-  * `:existing_atoms_only` - When true, raises an error
-    when non-existing atoms are found by the tokenizer.
-
-  ## Macro.to_binary/1
-
-  The opposite of converting a string to its AST is
-  `Macro.to_binary`, which converts a AST to a binary
-  representation.
-  """
-  def string_to_ast(string, opts // []) do
-    file = Keyword.get opts, :file, "nofile"
-    line = Keyword.get opts, :line, 1
-    res  = :elixir_translator.forms(:unicode.characters_to_list(string), line, file, opts)
-
-    case res do
-      { :ok, ast } -> { :ok, unpack_ast(line, ast) }
-      _ -> res
-    end
-  end
-
-  @doc """
-  Converts the given string to AST. 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 `Code.string_to_ast/2` for options information.
-  """
-  def string_to_ast!(string, opts // []) do
-    file = Keyword.get opts, :file, "nofile"
-    line = Keyword.get opts, :line, 1
-    res  = :elixir_translator.forms!(:unicode.characters_to_list(string), line, file, opts)
-    unpack_ast(line, res)
-  end
-
-  defp unpack_ast(_line, []),                              do: nil
-  defp unpack_ast(_line, [forms]) when not is_list(forms), do: forms
-  defp unpack_ast(line, forms),                            do: { :__block__, [line: line], forms }
-
-  @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 invoked concurrently
-  in many times. I.e. if `load_file` is called N times with
-  a given file, the given file will be loaded N times. Check
-  `require_file` if you don't want a file to be loaded concurrently.
-  """
-  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`. If
-  the file was already required/loaded, doesn't do anything and returns nil.
-
-  Notice that if `require_file` is invoked by different processes concurrently,
-  the first process to invoke `require_file` acquires a lock and the remaining
-  ones will block until the file is available. I.e. if `require_file` is called
-  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` if you want a file to be loaded concurrently.
-  """
-  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 """
-  Loads the compilation options from the code server.
-  Check compiler_options/1 for more information.
-  """
-  def compiler_options do
-    :elixir_code_server.call :compiler_options
-  end
-
-  @doc """
-  Sets compilation options. Those 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, for such reasons, false by default;
-  * ignore_module_conflict - when true, override modules that were already defined
-                             without raising errors, false by default;
-
-  """
-  def compiler_options(opts) do
-    :elixir_code_server.cast { :compiler_options, opts }
-  end
-
-  @doc """
-  Compiles the given string and returns a list of tuples where
-  the first element is the module name and the second one is its
-  binary.
-
-  For compiling many files at once, check `Kernel.ParallelCompiler`.
-  """
-  def compile_string(string, file // "nofile") when is_binary(file) do
-    :elixir_compiler.string :unicode.characters_to_list(string), file
-  end
-
-  @doc """
-  Compiles the quoted expression and returns a list of tuples where
-  the first element is the module name and the second one is its
-  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, it works as no-op. If the module was not loaded yet,
-  it tries to load it.
-
-  If it succeeds loading the module anyhow, 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 on 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 useful to check if a module is loaded
-  before using it and react accordingly. For example, the `URI` module
-  uses this function to check if a specific parser exists for a given
-  URI scheme.
-
-  ## Code.ensure_compiled
-
-  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 but it was not compiled yet, therefore
-  it can't even be loaded.
-
-  `ensure_compiled/1` puts a halt in the current process until the
-  module we are depending on is available.
-
-  In most of the cases, `ensure_loaded` is enough. `ensure_compiled`
-  must be used just in same rare conditions, usually involving macros
-  that needs to invoke a module for callback information.
-  """
-  def ensure_loaded(module) when is_atom(module) do
-    :code.ensure_loaded(module)
-  end
-
-  @doc """
-  Similar to `ensure_loaded/1`, but returns a boolean in case
-  it could be ensured or not.
-  """
-  def ensure_loaded?(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 just
-  then tries to load it.
-
-  If it succeeds loading the module anyhow, 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`.
-  """
-  def ensure_compiled(module) when is_atom(module) do
-    case :code.ensure_loaded(module) do
-      { :error, :nofile } = error ->
-        case :erlang.get(:elixir_ensure_compiled) do
-          :undefined -> error
-          _ ->
-            try do
-              module.__info__(:module)
-              { :module, module }
-            rescue
-              UndefinedFunctionError -> error
-            end
-        end
-      other -> other
-    end
-  end
-
-  @doc """
-  Similar to `ensure_compiled/1`, but returns a boolean in case
-  it could be ensured or not.
-  """
-  def ensure_compiled?(module) do
-    match?({ :module, ^module }, ensure_compiled(module))
-  end
-
-  ## 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 LoadError, file: file
-    end
-  end
-end
@@ -1,483 +0,0 @@
-defmodule Dict do
-  @moduledoc %B"""
-  This module specifies the Dict API expected to be
-  implemented by different dictionaries. It also provides
-  functions that redirect to the underlying Dict, allowing
-  a developer to work with different Dict implementations
-  using one API.
-
-  To create a new dict, use the `new` functions defined
-  by each dict type:
-
-      HashDict.new  #=> creates an empty HashDict
-
-  For simplicity's sake, in the examples below everytime
-  `new` is used, it implies one of the module-specific
-  calls like above. Likewise, when the result of a function
-  invocation is shown in the form `[a: 1, b: 2]`, it implies
-  that the returned value is actually of the same dict type
-  as the input one.
-
-  ## Protocols
-
-  Besides implementing the functions in this module, all
-  dictionaries are also required to implement the `Access`
-  protocol:
-
-      iex> dict = HashDict.new
-      ...> dict = Dict.put(dict, :hello, :world)
-      ...> dict[:hello]
-      :world
-
-  And also the `Enumerable` protocol, allowing one to write:
-
-      Enum.each(dict, fn ({ k, v }) ->
-        IO.puts "#{k}: #{v}"
-      end)
-
-  """
-
-  use Behaviour
-
-  @type key :: any
-  @type value :: any
-  @type keys :: [ key ]
-  @type t :: tuple | list
-
-  defcallback delete(t, key) :: t
-  defcallback drop(t, keys) :: t
-  defcallback empty(t) :: t
-  defcallback equal?(t, t) :: boolean
-  defcallback get(t, key) :: value
-  defcallback get(t, key, value) :: value
-  defcallback has_key?(t, key) :: boolean
-  defcallback keys(t) :: list(key)
-  defcallback merge(t, t) :: t
-  defcallback merge(t, t, (key, value, value -> value)) :: t
-  defcallback pop(t, key) :: {value, t}
-  defcallback pop(t, key, value) :: {value, t}
-  defcallback put(t, key, value) :: t
-  defcallback put_new(t, key, value) :: t
-  defcallback size(t) :: non_neg_integer()
-  defcallback split(t, keys) :: {t, t}
-  defcallback take(t, keys) :: t
-  defcallback to_list(t) :: list()
-  defcallback update(t, key, (value -> value)) :: t | no_return
-  defcallback update(t, key, value, (value -> value)) :: t
-  defcallback values(t) :: list(value)
-
-  defmacrop target(dict) do
-    quote do
-      cond do
-        is_tuple(unquote(dict)) ->
-          elem(unquote(dict), 0)
-        is_list(unquote(dict)) ->
-          ListDict
-      end
-    end
-  end
-
-  @doc """
-  Returns a list containing all dict's keys.
-  The keys are not guaranteed to be sorted, unless
-  the underlying dict implementation defines so.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> Enum.sort(Dict.keys(d))
-      [:a,:b]
-
-  """
-  @spec keys(t) :: [key]
-  def keys(dict) do
-    target(dict).keys(dict)
-  end
-
-  @doc """
-  Returns a list containing all dict's values.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> Enum.sort(Dict.values(d))
-      [1,2]
-
-  """
-  @spec values(t) :: [value]
-  def values(dict) do
-    target(dict).values(dict)
-  end
-
-  @doc """
-  Returns the number of elements in `dict`.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> Dict.size(d)
-      2
-
-  """
-  @spec size(t) :: non_neg_integer
-  def size(dict) do
-    target(dict).size(dict)
-  end
-
-  @doc """
-  Returns whether the given key exists in the given dict.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1])
-      iex> Dict.has_key?(d, :a)
-      true
-      iex> Dict.has_key?(d, :b)
-      false
-
-  """
-  @spec has_key?(t, key) :: boolean
-  def has_key?(dict, key) do
-    target(dict).has_key?(dict, key)
-  end
-
-  @doc """
-  Returns the value associated with `key` in `dict`. If `dict` does not
-  contain `key`, returns `default` (or nil if not provided).
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1])
-      iex> Dict.get(d, :a)
-      1
-      iex> Dict.get(d, :b)
-      nil
-      iex> Dict.get(d, :b, 3)
-      3
-  """
-  @spec get(t, key, value) :: value
-  def get(dict, key, default // nil) do
-    target(dict).get(dict, key, default)
-  end
-
-  @doc false
-  def get!(dict, key) do
-    target(dict).get!(dict, key)
-  end
-
-  @doc """
-  Returns the `{ :ok, value }` associated with `key` in `dict`.
-  If `dict` does not contain `key`, returns `:error`.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1])
-      iex> Dict.fetch(d, :a)
-      { :ok, 1 }
-      iex> Dict.fetch(d, :b)
-      :error
-
-  """
-  @spec fetch(t, key) :: value
-  def fetch(dict, key) do
-    target(dict).fetch(dict, key)
-  end
-
-  @doc """
-  Returns the value associated with `key` in `dict`. If `dict` does not
-  contain `key`, it raises `KeyError`.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1])
-      iex> Dict.fetch!(d, :a)
-      1
-      iex> Dict.fetch!(d, :b)
-      ** (KeyError) key not found: :b
-
-  """
-  @spec fetch!(t, key) :: value | no_return
-  def fetch!(dict, key) do
-    target(dict).fetch!(dict, key)
-  end
-
-  @doc """
-  Stores the given `value` under `key` in `dict`.
-  If `dict` already has `key`, the stored value is replaced by the new one.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.put(d, :a, 3)
-      ...> Dict.get(d, :a)
-      3
-
-  """
-  @spec put(t, key, value) :: t
-  def put(dict, key, val) do
-    target(dict).put(dict, key, val)
-  end
-
-  @doc """
-  Puts the given `value` under `key` in `dict` unless `key` already exists.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.put_new(d, :a, 3)
-      ...> Dict.get(d, :a)
-      1
-
-  """
-  @spec put_new(t, key, value) :: t
-  def put_new(dict, key, val) do
-    target(dict).put_new(dict, key, val)
-  end
-
-  @doc """
-  Removes the entry stored under the given key from `dict`.
-  If `dict` does not contain `key`, returns the dictionary unchanged.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.delete(d, :a)
-      ...> Dict.get(d, :a)
-      nil
-
-      iex> d = HashDict.new([b: 2])
-      ...> Dict.delete(d, :a) == d
-      true
-
-  """
-  @spec delete(t, key) :: t
-  def delete(dict, key) do
-    target(dict).delete(dict, key)
-  end
-
-  @doc """
-  Merges the given enum into the dict. In case one of the enum entries
-  alread exist in the dict, it is given higher preference.
-
-  ## Examples
-
-      iex> d1 = HashDict.new([a: 1, b: 2])
-      ...> d2 = HashDict.new([a: 3, d: 4])
-      ...> d = Dict.merge(d1, d2)
-      ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
-      [a: 3, b: 2, d: 4]
-
-  """
-  @spec merge(t, t) :: t
-  def merge(dict, enum) do
-    merge(dict, enum, fn(_k, _v1, v2) -> v2 end)
-  end
-
-  @doc """
-  Merges the given enum into the dict. In case one of the enum entries
-  alread exist in the dict, the given function is invoked to solve
-  conflicts.
-
-  ## Examples
-
-      iex> d1 = HashDict.new([a: 1, b: 2])
-      ...> d2 = HashDict.new([a: 3, d: 4])
-      ...> d = Dict.merge(d1, d2, fn(_k, v1, v2) ->
-      ...>   v1 + v2
-      ...> end)
-      ...> [a: Dict.get(d, :a), b: Dict.get(d, :b), d: Dict.get(d, :d)]
-      [a: 4, b: 2, d: 4]
-
-  """
-  @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(dict, enum, fun) do
-    target(dict).merge(dict, enum, fun)
-  end
-
-  @doc """
-  Returns the value associated with `key` in `dict` as
-  well as the `dict` without `key`.
-
-  ## Examples
-
-      iex> dict = HashDict.new [a: 1]
-      ...> {v, d} = Dict.pop dict, :a
-      ...> {v, Enum.sort(d)}
-      {1,[]}
-
-      iex> dict = HashDict.new [a: 1]
-      ...> {v, d} = Dict.pop dict, :b
-      ...> {v, Enum.sort(d)}
-      {nil,[a: 1]}
-
-      iex> dict = HashDict.new [a: 1]
-      ...> {v, d} = Dict.pop dict, :b, 3
-      ...> {v, Enum.sort(d)}
-      {3,[a: 1]}
-
-  """
-  @spec pop(t, key, value) :: {value, t}
-  def pop(dict, key, default // nil) do
-    target(dict).pop(dict, key, default)
-  end
-
-  @doc """
-  Update a value in `dict` by calling `fun` on the value to get a new
-  value. An exception is generated if `key` is not present in the dict.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.update(d, :a, fn(val) -> -val end)
-      ...> Dict.get(d, :a)
-      -1
-
-  """
-  @spec update(t, key, (value -> value)) :: t
-  def update(dict, key, fun) do
-    target(dict).update(dict, key, fun)
-  end
-
-  @doc """
-  Update a value in `dict` by calling `fun` on the value to get a new value. If
-  `key` is not present in `dict` then `initial` will be stored as the first
-  value.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.update(d, :c, 3, fn(val) -> -val end)
-      ...> Dict.get(d, :c)
-      3
-
-  """
-  @spec update(t, key, value, (value -> value)) :: t
-  def update(dict, key, initial, fun) do
-    target(dict).update(dict, key, initial, fun)
-  end
-
-  @doc """
-  Returns a tuple of two dicts, where the first dict contains only
-  entries from `dict` with keys in `keys`, and the second dict
-  contains only entries from `dict` with keys not in `keys`
-
-  Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> { d1, d2 } = Dict.split(d, [:a, :c])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
-      { [a: 1], [b: 2] }
-
-      iex> d = HashDict.new([])
-      ...> { d1, d2 } = Dict.split(d, [:a, :c])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
-      { [], [] }
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> { d1, d2 } = Dict.split(d, [:a, :b, :c])
-      ...> { Dict.to_list(d1), Dict.to_list(d2) }
-      { [a: 1, b: 2], [] }
-
-  """
-  @spec split(t, keys) :: {t, t}
-  def split(dict, keys) do
-    target(dict).split(dict, keys)
-  end
-
-  @doc """
-  Returns a new dict where the the given `keys` a removed from `dict`.
-  Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.drop(d, [:a, :c, :d])
-      ...> Dict.to_list(d)
-      [b: 2]
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...> d = Dict.drop(d, [:c, :d])
-      ...> Dict.to_list(d)
-      [a: 1, b: 2]
-
-  """
-  @spec drop(t, keys) :: t
-  def drop(dict, keys) do
-    target(dict).drop(dict, keys)
-  end
-
-  @doc """
-  Returns a new dict where only the keys in `keys` from `dict` are
-  included. Any non-member keys are ignored.
-
-  ## Examples
-
-      iex> d = HashDict.new([a: 1, b: 2])
-      ...>
-      ...> d = Dict.take(d, [:a, :c, :d])
-      ...> Dict.to_list(d)
-      [a: 1]
-      ...>
-      ...> d = Dict.take(d, [:c, :d])
-      ...> Dict.to_list(d)
-      []
-
-  """
-  @spec take(t, keys) :: t
-  def take(dict, keys) do
-    target(dict).take(dict, keys)
-  end
-
-  @doc """
-  Returns an empty dict of the same type as `dict`.
-  """
-  @spec empty(t) :: t
-  def empty(dict) do
-    target(dict).empty(dict)
-  end
-
-  @doc """
-  Check if two dicts are equal, if the dicts are of different types they're
-  first converted to lists.
-
-  ## Examples
-
-      iex> a = HashDict.new(a: 2, b: 3, f: 5, c: 123)
-      ...> b = ListDict.new(a: 2, b: 3, f: 5, c: 123)
-      ...> Dict.equal?(a, b)
-      true
-
-      iex> a = HashDict.new(a: 2, b: 3, f: 5, c: 123)
-      ...> b = []
-      ...> Dict.equal?(a, b)
-      false
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(a, b) do
-    a_target = target(a)
-    b_target = target(b)
-
-    cond do
-      a_target == b_target ->
-        a_target.equal?(a, b)
-
-      a_target.size(a) == b_target.size(b) ->
-        ListDict.equal?(a_target.to_list(a), b_target.to_list(b))
-
-      true ->
-        false
-    end
-  end
-
-  @doc """
-  Returns a list of key-value pairs stored in `dict`.
-  No particular order is enforced.
-  """
-  @spec to_list(t) :: list
-  def to_list(dict) do
-    target(dict).to_list(dict)
-  end
-end
@@ -1,288 +0,0 @@
-defexception RuntimeError,      message: "runtime error"
-defexception ArgumentError,     message: "argument error"
-defexception ArithmeticError,   message: "bad argument in arithmetic expression"
-defexception SystemLimitError,  message: "a system limit has been reached"
-
-defexception SyntaxError, [file: nil, line: nil, description: "syntax error"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception TokenMissingError, [file: nil, line: nil, description: "expression is incomplete"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception CompileError, [file: nil, line: nil, description: "compile error"] do
-  def message(exception) do
-    "#{Exception.format_file_line(exception.file, exception.line, nil)}#{exception.description}"
-  end
-end
-
-defexception BadFunctionError, [actual: nil] do
-  def message(exception) do
-    "expected a function, got: #{inspect(exception.actual)}"
-  end
-end
-
-defexception MatchError, [actual: nil] do
-  def message(exception) do
-    "no match of right hand side value: #{inspect(exception.actual)}"
-  end
-end
-
-defexception CaseClauseError, [actual: nil] do
-  def message(exception) do
-    "no case clause matching: #{inspect(exception.actual)}"
-  end
-end
-
-defexception BadArityError, [function: nil, args: nil] do
-  def message(exception) do
-    "bad arity error: #{inspect(exception.function)} called with #{inspect(exception.args)}"
-  end
-end
-
-defexception UndefinedFunctionError, [module: nil, function: nil, arity: nil] do
-  def message(exception) do
-    if exception.function do
-      formatted = Exception.format_module_fun_arity exception.module, exception.function, exception.arity
-      "undefined function: #{formatted}"
-    else
-      "undefined function"
-    end
-  end
-end
-
-defexception FunctionClauseError, [module: nil, function: nil, arity: nil] do
-  def message(exception) do
-    if exception.function do
-      formatted = Exception.format_module_fun_arity exception.module, exception.function, exception.arity
-      "no function clause matching in #{formatted}"
-    else
-      "no function clause matches"
-    end
-  end
-end
-
-defexception Protocol.UndefinedError, [protocol: nil, structure: nil, extra: nil] do
-  def message(exception) do
-    msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.structure}"
-    if exception.extra do
-      msg <> ". " <> exception.extra
-    else
-      msg
-    end
-  end
-end
-
-defexception ErlangError, [original: nil] do
-  def message(exception) do
-    "erlang error: #{inspect(exception.original)}"
-  end
-end
-
-defexception KeyError, key: nil do
-  def message(exception) do
-    "key not found: #{inspect exception.key}"
-  end
-end
-
-defexception Enum.OutOfBoundsError, message: "out of bounds error"
-
-defexception Enum.EmptyError, message: "empty error"
-
-defmodule Exception do
-  @moduledoc """
-  Several convenience functions to work and pretty print
-  exceptions and stacktraces.
-  """
-
-  @doc """
-  Normalizes an exception converting Erlang exceptions
-  to Elixir exceptions. Useful when interfacing Erlang
-  code with Elixir code.
-  """
-  def normalize(exception) when is_exception(exception) do
-    exception
-  end
-
-  def normalize(:badarg) do
-    ArgumentError[]
-  end
-
-  def normalize(:badarith) do
-    ArithmeticError[]
-  end
-
-  def normalize(:system_limit) do
-    SystemLimitError[]
-  end
-
-  def normalize({ :badarity, { fun, args } }) do
-    BadArityError[function: fun, args: args]
-  end
-
-  def normalize({ :badfun, actual }) do
-    BadFunctionError[actual: actual]
-  end
-
-  def normalize({ :badmatch, actual }) do
-    MatchError[actual: actual]
-  end
-
-  def normalize({ :case_clause, actual }) do
-    CaseClauseError[actual: actual]
-  end
-
-  def normalize(:undef) do
-    { mod, fun, arity } = from_stacktrace(:erlang.get_stacktrace)
-    UndefinedFunctionError[module: mod, function: fun, arity: arity]
-  end
-
-  def normalize(:function_clause) do
-    { mod, fun, arity } = from_stacktrace(:erlang.get_stacktrace)
-    FunctionClauseError[module: mod, function: fun, arity: arity]
-  end
-
-  def normalize({ :badarg, payload }) do
-    ArgumentError[message: "argument error: #{inspect(payload)}"]
-  end
-
-  def normalize(other) do
-    ErlangError[original: other]
-  end
-
-  @doc """
-  Receives a tuple representing a stacktrace entry and formats it.
-  The current working directory may be given as argument, which
-  is used to prettify the stacktrace.
-  """
-  def format_stacktrace_entry(entry, cwd // nil)
-
-  # From Macro.Env.stacktrace
-  def format_stacktrace_entry({ module, :__MODULE__, 0, file_line }, cwd) do
-    "#{format_file_line(file_line, cwd)}#{inspect module} (module)"
-  end
-
-  # From :elixir_compiler
-  def format_stacktrace_entry({ _module, :__MODULE__, 2, file_line }, cwd) do
-    "#{format_file_line(file_line, cwd)}(module)"
-  end
-
-  # From :elixir_compiler
-  def format_stacktrace_entry({ _module, :__FILE__, 2, file_line }, cwd) do
-    "#{format_file_line(file_line, cwd)}(file)"
-  end
-
-  def format_stacktrace_entry({module, fun, arity, file_line}, cwd) do
-    "#{format_file_line(file_line, cwd)}#{format_module_fun_arity(module, fun, arity)}"
-  end
-
-  def format_stacktrace_entry({fun, arity, file_line}, cwd) do
-    "#{format_file_line(file_line, cwd)}#{format_fun_arity(fun, arity)}"
-  end
-
-  @doc """
-  Formats the stacktrace.
-
-  A stacktrace must be given as argument. If not, this function
-  calculates the current stacktrace and formats it. As consequence,
-  the value of `System.stacktrace` is changed.
-  """
-  def format_stacktrace(trace // nil)
-
-  def format_stacktrace(trace) do
-    trace = trace || try do
-      throw(:stacktrace)
-    catch
-      :stacktrace -> Enum.drop(:erlang.get_stacktrace, 1)
-    end
-
-    case trace do
-      [] -> "\n"
-      s  -> "    " <> Enum.map_join(s, "\n    ", format_stacktrace_entry(&1)) <> "\n"
-    end
-  end
-
-  @doc """
-  Prints the current stacktrace to standard output.
-
-  A stacktrace must be given as argument. If not, this function
-  calculates the current stacktrace and formats it. As consequence,
-  the value of `System.stacktrace` is changed.
-  """
-  def print_stacktrace(trace // nil) do
-    IO.write format_stacktrace(trace)
-  end
-
-  ## Helpers
-
-  # Format fun and arity
-  @doc false
-  def format_fun_arity(fun, arity) do
-    if is_list(arity) do
-      inspected = lc x inlist arity, do: inspect(x)
-      "#{inspect fun}(#{Enum.join(inspected, ", ")})"
-    else
-      "#{inspect fun}/#{arity}"
-    end
-  end
-
-  # Receives a module, fun and arity and returns a string
-  # representing such invocation. Arity may also be a list
-  # of arguments. It follows the same syntax as in stacktraces.
-  @doc false
-  def format_module_fun_arity(module, fun, arity) do
-    fun =
-      case inspect(fun) do
-        << ?:, erl :: binary >> -> erl
-        elixir -> elixir
-      end
-
-    if is_list(arity) do
-      inspected = lc x inlist arity, do: inspect(x)
-      "#{inspect module}.#{fun}(#{Enum.join(inspected, ", ")})"
-    else
-      "#{inspect module}.#{fun}/#{arity}"
-    end
-  end
-
-  # Format file and line for exception printing.
-  @doc false
-  def format_file_line(opts, cwd) do
-    format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), cwd
-  end
-
-  def format_file_line(file, line, cwd) do
-    if file do
-      file = to_binary(file)
-
-      if cwd do
-        file = Path.relative_to(file, cwd)
-      end
-
-      if line && line != 0 do
-        "#{file}:#{line}: "
-      else
-        "#{file}: "
-      end
-    else
-      ""
-    end
-  end
-
-  defp from_stacktrace([{ module, function, args, _ }|_]) when is_list(args) do
-    { module, function, length(args) }
-  end
-
-  defp from_stacktrace([{ module, function, arity, _ }|_]) do
-    { module, function, arity }
-  end
-
-  defp from_stacktrace(_) do
-    { nil, nil, nil }
-  end
-end
@@ -1,96 +0,0 @@
-defmodule GenEvent.Behaviour do
-  @moduledoc """
-  This module is a convenience to define GenEvent callbacks in Elixir.
-
-  GenEvent is an OTP behaviour that encapsulates event handling functionality.
-
-  ## Example
-
-  Bellow follows an example of a GenEvent that stores notifications
-  until they are fetched:
-
-      defmodule MyEventHandler do
-        use GenEvent.Behaviour
-
-        # Callbacks
-
-        def init(_) do
-          { :ok, [] }
-        end
-
-        def handle_event({:notification, x}, notifications) do
-          { :ok, [x|notifications] }
-        end
-
-        def handle_call(:notifications, notifications) do
-          {:ok, Enum.reverse(notifications), []}
-        end
-
-      end
-
-      { :ok, pid } = :gen_event.start_link
-
-      :gen_event.add_handler(pid, MyEventHandler, [])
-
-      :gen_event.notify(pid, {:notification, 1})
-      :gen_event.notify(pid, {:notification, 2})
-      
-      :gen_event.call(pid, MyEventHandler, :notifications)
-      #=> [1, 2]
-
-      :gen_event.call(pid, MyEventHandler, :notifications)
-      #=> []
-
-  Notice we never call the server callbacks directly, they are called
-  by OTP whenever we interact with the server. 
-
-  Starting and sending messages to gen_event is done
-  via Erlang's `:gen_event` module. For more information,
-  please refer to the following:
-
-  http://www.erlang.org/doc/man/gen_event.html
-  http://learnyousomeerlang.com/event-handlers
-  """
-
-  @doc false
-  defmacro __using__(_) do
-    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(_request, state) do
-        { :ok, :ok, state }
-      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
-end
@@ -1,125 +0,0 @@
-defmodule GenServer.Behaviour do
-  @moduledoc """
-  This module is a convenience to define GenServer callbacks in Elixir.
-
-  A server is responsible to react to messages received from client
-  and a GenServer is an OTP behaviour that encapsulates common server
-  functionalities.
-
-  ## Example
-
-  Bellow follows an example of a GenServer that push and pop items
-  into a stack:
-
-      defmodule MyServer do
-        use GenServer.Behaviour
-
-        # Callbacks
-
-        def handle_call(:pop, _from, [h|t]) do
-          { :reply, h, t }
-        end
-
-        def handle_call(_request, _from, _config) do
-          # Call the default implementation from GenServer.Behaviour
-          super
-        end
-
-        def handle_cast({ :push, item }, config) do
-          { :noreply, [item|config] }
-        end
-
-        def handle_cast(_request, _config) do
-          super
-        end
-      end
-
-      { :ok, pid } = :gen_server.start_link(MyServer, [:hello], [])
-
-      :gen_server.call(pid, :pop)
-      #=> :hello
-
-      :gen_server.cast(pid, { :push, :world })
-      #=> :ok
-
-      :gen_server.call(pid, :pop)
-      #=> :world
-
-  Notice we never call the server callbacks directly, they are called
-  by OTP whenever we interact with the server. **cast** messages are
-  asynchronous while **call** ones are synchronous.  In the case of
-  GenServer's, there are 8 different values a callback such as
-  `handle_call` or `handle_cast` can return:
-
-      { :reply, reply, new_state }
-      { :reply, reply, new_state, timeout }
-      { :reply, reply, new_state, :hibernate }
-      { :noreply, new_state }
-      { :noreply, new_state, timeout }
-      { :noreply, new_state, :hibernate }
-      { :stop, reason, new_state }
-      { :stop, reason, reply, new_state }
-
-  There are 6 callbacks required to be implemented in a GenServer. The
-  `GenServer.Behaviour` module defines all of them automatically, but
-  allows us to customize the ones we need. The list of callbacks are:
-
-  * `init(args)` - invoked when the server is started;
-  * `handle_call(msg, from, state)` - invoked to handle call messages;
-  * `handle_cast(msg, state)` - invoked to handle cast messages;
-  * `handle_info(msg, state)` - handle all other messages which are
-     normally received by processes;
-  * `terminate(reason, state)` - called when the server is about to
-     terminate, useful for cleaning up;
-  * `code_change(old_vsn, state, extra)` - called when the application
-    code is being upgraded live (hot code swap);
-
-  Starting and sending messages to the gen_server is done
-  via Erlang's `:gen_server` module. For more information,
-  please refer to the following:
-
-  http://www.erlang.org/doc/man/gen_server.html
-  http://www.erlang.org/doc/design_principles/gen_server_concepts.html
-  http://learnyousomeerlang.com/clients-and-servers
-  """
-
-  @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behavior :gen_server
-
-      @doc false
-      def init(args) do
-        { :ok, args }
-      end
-
-      @doc false
-      def handle_call(_request, _from, state) do
-        { :noreply, state }
-      end
-
-      @doc false
-      def handle_info(_msg, state) do
-        { :noreply, state }
-      end
-
-      @doc false
-      def handle_cast(_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
-
-      defoverridable [init: 1, handle_call: 3, handle_info: 2,
-        handle_cast: 2, terminate: 2, code_change: 3]
-    end
-  end
-end
@@ -1,619 +0,0 @@
-defmodule HashDict do
-  @moduledoc """
-  A key-value store.
-
-  The `HashDict` is meant to work well with both small and
-  large set of keys and it is an implementation of the `Dict`
-  behaviour. For more information about the functions and
-  their APIs, please consult the `Dict` module.
-  """
-
-  @behaviour Dict
-
-  # A dictionary (key-value) implementation based on dynamic hashing.
-  #
-  # This implementation is based on hash tries. We first start with
-  # a set of 8 buckets and expand when the density is about 5 entries
-  # per bucket. We use bit shifting to make rehashing faster on
-  # expansion.
-  #
-  # Compared to dict, it provides many enhancements:
-  #
-  # 1. HashDict buckets are ordered sets, this gives us faster access
-  #    and modification times
-  #
-  # 2. It uses phash2 to calculate the hash (instead of phash)
-  #
-  # 3. The dictionary first starts with a single bucket, instead of
-  #    a set of 8 buckets. This allow us to skip hashing altogher
-  #    for small dictionaries, providing faster operations and
-  #    reducing memory consumption
-  #
-  # 4. Once we reach 8 elements, the dictionary is promoted to a
-  #    set of buckets
-
-  # The ordered record contains a single bucket
-  @ordered_threshold 8
-
-  defrecordp :ordered,
-    size: 0,
-    bucket: []
-
-  # The bucketed record contains a series of buckets.
-  @expand_load 5
-  @contract_load 2
-  @node_bitmap 0b111
-  @node_shift 3
-  @node_size 8
-  @node_template :erlang.make_tuple(@node_size, [])
-
-  defrecordp :trie,
-    size: 0,
-    depth: 0,
-    expand_on: @node_size * @expand_load,
-    contract_on: @contract_load,
-    root: @node_template
-
-  import Bitwise
-
-  # Let's inline common instructions
-  @compile { :inline, bucket_hash: 1, bucket_index: 1, bucket_nth_index: 2, bucket_next: 1 }
-
-  @doc """
-  Creates a new empty dict.
-  """
-  @spec new :: Dict.t
-  def new do
-    ordered()
-  end
-
-  @doc """
-  Creates a new dict from the given enumerable.
-
-  ## Examples
-
-      HashDict.new [{:b,1},{:a,2}]
-      #=> #HashDict<[a: 2, b: 1]>
-
-  """
-  @spec new(list({key :: term, value :: term})) :: Dict.t
-  def new(pairs) do
-    Enum.reduce pairs, ordered(), fn { k, v }, dict ->
-      put(dict, k, v)
-    end
-  end
-
-  @doc """
-  Creates a new dict from the enumerable with the
-  help of the transformation function.
-
-  ## Examples
-
-      HashDict.new ["a", "b"], fn x -> {x, x} end
-      #=> #HashDict<[{"a","a"},{"b","b"}]>
-
-  """
-  @spec new(list, (term -> {key :: term, value ::term})) :: Dict.t
-  def new(list, transform) when is_function(transform) do
-    Enum.reduce list, new(), fn i, dict ->
-      { k, v } = transform.(i)
-      put(dict, k, v)
-    end
-  end
-
-  @doc """
-  Puts the given key and value in the dict.
-  """
-  def put(dict, key, value) do
-    { dict, _ } = dict_put(dict, key, { :put, value })
-    dict
-  end
-
-  @doc """
-  Puts the given value under key in the dictionary
-  only if one does not exist yet.
-  """
-  def put_new(dict, key, value) do
-    update(dict, key, value, fn(v) -> v end)
-  end
-
-  @doc """
-  Updates the key in the dictionary according
-  to the given function. Raises if the key does
-  not exist in the dictionary.
-  """
-  def update(dict, key, fun) when is_function(fun, 1) do
-    case dict_put(dict, key, { :update, nil, fun }) do
-      { dict, 0 } ->
-        dict
-      { _dict, 1 } ->
-        raise KeyError, key: key
-    end
-  end
-
-  @doc """
-  Updates the key in the dictionary according
-  to the given function. Adds initial value if
-  the key does not exist in the dicionary.
-  """
-  def update(dict, key, initial, fun) when is_function(fun, 1) do
-    { dict, _ } = dict_put(dict, key, { :update, initial, fun })
-    dict
-  end
-
-  @doc """
-  Gets the value under key from the dict.
-  """
-  def get(dict, key, default // nil) do
-    case dict_get(dict, key) do
-      { ^key, value } -> value
-      false -> default
-    end
-  end
-
-  @doc """
-  Fetches the value under key from the dict
-  and return it in a tagged tuple.
-  """
-  def fetch(dict, key) do
-    case dict_get(dict, key) do
-      { ^key, value } -> { :ok, value }
-      false -> :error
-    end
-  end
-
-  def fetch!(dict, key) when is_tuple(dict) do
-    case dict_get(dict, key) do
-      { ^key, value } -> value
-      false -> raise(KeyError, key: key)
-    end
-  end
-
-
-  @doc """
-  Checks if the dict has the given key.
-  """
-  def has_key?(dict, key) do
-    match? { ^key, _ }, dict_get(dict, key)
-  end
-
-  @doc """
-  Returns the value under key from the dict as well as the dict without key.
-  """
-  def pop(dict, key, default // nil) do
-    case dict_delete(dict, key) do
-      { dict, _, 0 } -> { default, dict }
-      { dict, value, _ } -> { value, dict }
-    end
-  end
-
-  @doc """
-  Deletes a value from the dict.
-  """
-  def delete(dict, key) do
-    { dict, _, _ } = dict_delete(dict, key)
-    dict
-  end
-
-  @doc """
-  Returns the dict size.
-  """
-  def size(dict) do
-    elem(dict, 1)
-  end
-
-  @doc """
-  Returns an empty dict.
-  """
-  def empty(_) do
-    ordered()
-  end
-
-  def equal?(dict1, dict2) do
-    size = elem(dict1, 1)
-    case elem(dict2, 1) do
-      ^size ->
-        dict_equal?(dict1, dict1)
-      _ ->
-        false
-    end
-  end
-
-  @doc """
-  Converts the dict to a list.
-  """
-  def to_list(ordered(bucket: bucket)) do
-    bucket
-  end
-
-  def to_list(dict) do
-    dict_fold(dict, [], [&1|&2]) |> :lists.reverse
-  end
-
-  @doc """
-  Get all keys in the dict.
-  """
-  def keys(dict) do
-    dict_fold(dict, [], fn { k, _ }, acc -> [k|acc] end)
-  end
-
-  @doc """
-  Get all values in the dict.
-  """
-  def values(dict) do
-    dict_fold(dict, [], fn { _, v }, acc -> [v|acc] end)
-  end
-
-  @doc """
-  Merges two dictionaries.
-  """
-  def merge(dict, enum, callback // fn(_k, _v1, v2) -> v2 end)
-
-  def merge(dict1, dict2, callback) when is_record(dict1, HashDict) and is_record(dict2, HashDict) and elem(dict1, 1) < elem(dict2, 1) do
-    dict_fold dict1, dict2, fn { k, v1 }, acc ->
-      update(acc, k, v1, callback.(k, v1, &1))
-    end
-  end
-
-  def merge(dict1, dict2, callback) when is_record(dict1, HashDict) and is_record(dict2, HashDict) do
-    dict_fold dict2, dict1, fn { k, v2 }, acc ->
-      update(acc, k, v2, callback.(k, &1, v2))
-    end
-  end
-
-  def merge(dict1, dict2, callback) when is_record(dict1, HashDict) do
-    Enum.reduce dict2, dict1, fn { k, v2 }, acc ->
-      update(acc, k, v2, callback.(k, &1, v2))
-    end
-  end
-
-  @doc """
-  Splits a dict into two dicts,
-  one containing entries with key in the keys list,
-  and another containing entries with key not in keys.
-  Returns a 2-tuple of the new dicts.
-  """
-  def split(dict, keys) do
-    split(keys, new, dict)
-  end
-
-  defp split([], including, excluding) do
-    { including, excluding }
-  end
-
-  defp split([key|keys], including, excluding) do
-    case dict_delete(excluding, key) do
-      { excluding, _, 0 } -> split(keys, including, excluding)
-      { excluding, value, _ } -> split(keys, put(including, key, value), excluding)
-    end
-  end
-
-  @doc """
-  Returns a new dict with only the entries
-  which key is in keys.
-  """
-  def take(dict, keys) do
-    take(dict, keys, new)
-  end
-
-  defp take(_dict, [], acc), do: acc
-  defp take(dict, [key|keys], acc) do
-    case fetch(dict, key) do
-      { :ok, value } -> take(dict, keys, put(acc, key, value))
-      :error -> take(dict, keys, acc)
-    end
-  end
-
-  @doc """
-  Returns a new dict with only the entries
-  which key is not in keys
-  """
-  def drop(dict, []), do: dict
-
-  def drop(dict, [key|keys]) do
-    drop(delete(dict, key), keys)
-  end
-
-  def reduce(ordered(bucket: bucket), acc, fun) do
-    :lists.foldl(fun, acc, bucket)
-  end
-
-  def reduce(trie() = dict, acc, fun) do
-    dict_fold(dict, acc, fun)
-  end
-
-  ## Dict-wide functions
-
-  defp dict_get(ordered(bucket: bucket), key) do
-    bucket_get(bucket, key)
-  end
-
-  defp dict_get(trie(root: root, depth: depth), key) do
-    bucket_get(node_bucket(root, depth, bucket_hash(key)), key)
-  end
-
-  defp dict_fold(ordered(bucket: bucket), acc, fun) do
-    bucket_fold(bucket, acc, fun)
-  end
-
-  defp dict_fold(trie(root: root, depth: depth), acc, fun) do
-    node_fold(root, depth, acc, fun, @node_size)
-  end
-
-  defp dict_put(ordered(size: @ordered_threshold, bucket: bucket), key, value) do
-    root = node_relocate(bucket, 0)
-    dict_put(trie(size: @ordered_threshold, root: root), key, value)
-  end
-
-  defp dict_put(ordered(size: size, bucket: bucket) = dict, key, value) do
-    { new, count } = bucket_put(bucket, key, value)
-    { ordered(dict, size: size + count, bucket: new), count }
-  end
-
-  defp dict_put(trie(root: root, depth: depth, size: size, expand_on: size, contract_on: contract_on) = dict, key, value) do
-    root = node_expand(root, depth, depth + 1)
-    dict = trie(dict, root: root, depth: depth + 1,
-      expand_on: size * @node_size, contract_on: contract_on * @node_size)
-    dict_put(dict, key, value)
-  end
-
-  defp dict_put(trie(root: root, size: size, depth: depth) = dict, key, value) do
-    pos = bucket_hash(key)
-    { root, count } = node_put(root, depth, pos, key, value)
-    { trie(dict, size: size + count, root: root), count }
-  end
-
-  defp dict_delete(ordered(bucket: bucket, size: size) = dict, key) do
-    case bucket_delete(bucket, key) do
-      { _, value, 0 } ->
-        { dict, value, 0 }
-      { new_bucket, value, -1 } ->
-        { ordered(dict, size: size - 1, bucket: new_bucket), value, -1 }
-    end
-  end
-
-  defp dict_delete(trie(root: root, size: size, depth: depth) = dict, key) do
-    pos = bucket_hash(key)
-    case node_delete(root, depth, pos, key) do
-      { _, value, 0 } ->
-        { dict, value, 0 }
-      { root, value, -1 } ->
-        { if depth > 0 and trie(dict, :contract_on) == size do
-          root = node_contract(root, depth, depth - 1)
-          trie(dict,
-            root: root,
-            size: size - 1,
-            depth: depth - 1,
-            contract_on: div(size, @node_size),
-            expand_on: div(trie(dict, :expand_on), @node_size))
-        else
-          trie(dict, size: size - 1, root: root)
-        end, value, -1 }
-    end
-  end
-
-  defp dict_equal?(dict1, dict2) do
-    try do
-      reduce(dict1, true, fn({ key, value }, acc) ->
-        case fetch(dict2, key) do
-          { _ok, ^value } ->
-            acc
-          _ ->
-            throw(:error)
-        end
-      end)
-    catch
-      :error -> false
-    end
-  end
-
-  ## Bucket helpers
-
-  # Get value from the bucket
-  defp bucket_get([{k,_}|_bucket], key) when k > key do
-    false
-  end
-
-  defp bucket_get([{key,_}=e|_bucket], key) do
-    e
-  end
-
-  defp bucket_get([_e|bucket], key) do
-    bucket_get(bucket, key)
-  end
-
-  defp bucket_get([], _key) do
-    false
-  end
-
-  # Puts a value in the bucket
-  defp bucket_put([{k,_}|_]=bucket, key, { :put, value }) when k > key do
-    { [{key, value}|bucket], 1 }
-  end
-
-  defp bucket_put([{k,_}|_]=bucket, key, { :update, initial, _fun }) when k > key do
-    { [{key, initial}|bucket], 1 }
-  end
-
-  defp bucket_put([{key,_}|bucket], key, { :put, value }) do
-    { [{key,value}|bucket], 0 }
-  end
-
-  defp bucket_put([{key,value}|bucket], key, { :update, _initial, fun }) do
-    { [{key, fun.(value)}|bucket], 0 }
-  end
-
-  defp bucket_put([e|bucket], key, value) do
-    { rest, count } = bucket_put(bucket, key, value)
-    { [e|rest], count }
-  end
-
-  defp bucket_put([], key, { :put, value }) do
-    { [{key,value}], 1 }
-  end
-
-  defp bucket_put([], key, { :update, initial, _fun }) do
-    { [{key,initial}], 1 }
-  end
-
-  # Puts a value in the bucket without returning
-  # the operation value
-  defp bucket_put!([{k,_}|_]=bucket, key, value) when k > key, do: [{key,value}|bucket]
-  defp bucket_put!([{key,_}|bucket], key, value), do: [{key,value}|bucket]
-  defp bucket_put!([{_,_}=e|bucket], key, value), do: [e|bucket_put!(bucket, key, value)]
-  defp bucket_put!([], key, value), do: [{key,value}]
-
-  # Deletes a key from the bucket
-  defp bucket_delete([{k,_}|_]=bucket, key) when k > key do
-    { bucket, nil, 0 }
-  end
-
-  defp bucket_delete([{key,value}|bucket], key) do
-    { bucket, value, -1 }
-  end
-
-  defp bucket_delete([e|bucket], key) do
-    { rest, value, count } = bucket_delete(bucket, key)
-    { [e|rest], value, count }
-  end
-
-  defp bucket_delete([], _key) do
-    { [], nil, 0 }
-  end
-
-  # Folds the bucket
-  defp bucket_fold(bucket, acc, fun) do
-    :lists.foldl(fun, acc, bucket)
-  end
-
-  defp bucket_hash(key) do
-    :erlang.phash2(key)
-  end
-
-  defp bucket_index(hash) do
-    hash &&& @node_bitmap
-  end
-
-  defp bucket_nth_index(hash, n) do
-    (hash >>> (@node_shift * n)) &&& @node_bitmap
-  end
-
-  defp bucket_next(hash) do
-    hash >>> @node_shift
-  end
-
-  ## Node helpers
-
-  # Gets a bucket from the node
-  defp node_bucket(node, 0, hash) do
-    elem(node, bucket_index(hash))
-  end
-
-  defp node_bucket(node, depth, hash) do
-    child = elem(node, bucket_index(hash))
-    node_bucket(child, depth - 1, bucket_next(hash))
-  end
-
-  # Puts a key-value into a node
-  defp node_put(node, 0, hash, key, value) do
-    pos = bucket_index(hash)
-    { new, count } = bucket_put(elem(node, pos), key, value)
-    { set_elem(node, pos, new), count }
-  end
-
-  defp node_put(node, depth, hash, key, value) do
-    pos = bucket_index(hash)
-    { new, count } = node_put(elem(node, pos), depth - 1, bucket_next(hash), key, value)
-    { set_elem(node, pos, new), count }
-  end
-
-  # Deletes a key from the bucket
-  defp node_delete(node, 0, hash, key) do
-    pos = bucket_index(hash)
-    case bucket_delete(elem(node, pos), key) do
-      { _, value, 0 } -> { node, value, 0 }
-      { new, value, -1 } -> { set_elem(node, pos, new), value, -1 }
-    end
-  end
-
-  defp node_delete(node, depth, hash, key) do
-    pos = bucket_index(hash)
-    case node_delete(elem(node, pos), depth - 1, bucket_next(hash), key) do
-      { _, value, 0 } -> { node, value, 0 }
-      { new, value, -1 } -> { set_elem(node, pos, new), value, -1 }
-    end
-  end
-
-  # Folds a node recursively
-  defp node_fold(bucket, -1, acc, fun, _) do
-    bucket_fold(bucket, acc, fun)
-  end
-
-  defp node_fold(node, depth, acc, fun, count) when count >= 1 do
-    acc = node_fold(:erlang.element(count, node), depth - 1, acc, fun, @node_size)
-    node_fold(node, depth, acc, fun, count - 1)
-  end
-
-  defp node_fold(_node, _, acc, _fun, 0) do
-    acc
-  end
-
-  # Node resizing
-  defp node_expand({ b1, b2, b3, b4, b5, b6, b7, b8 }, 0, n) do
-    { node_relocate(b1, n), node_relocate(b2, n), node_relocate(b3, n),
-      node_relocate(b4, n), node_relocate(b5, n), node_relocate(b6, n),
-      node_relocate(b7, n), node_relocate(b8, n) }
-  end
-
-  defp node_expand({ b1, b2, b3, b4, b5, b6, b7, b8 }, depth, n) do
-    depth = depth - 1
-    { node_expand(b1, depth, n), node_expand(b2, depth, n), node_expand(b3, depth, n),
-      node_expand(b4, depth, n), node_expand(b5, depth, n), node_expand(b6, depth, n),
-      node_expand(b7, depth, n), node_expand(b8, depth, n) }
-  end
-
-  defp node_contract({ b1, b2, b3, b4, b5, b6, b7, b8 }, depth, n) when depth > 1 do
-    depth = depth - 1
-    { node_contract(b1, depth, n), node_contract(b2, depth, n), node_contract(b3, depth, n),
-      node_contract(b4, depth, n), node_contract(b5, depth, n), node_contract(b6, depth, n),
-      node_contract(b7, depth, n), node_contract(b8, depth, n) }
-  end
-
-  defp node_contract({ b1, b2, b3, b4, b5, b6, b7, b8 }, 1, n) do
-    @node_template |> each_contract(b1, n) |> each_contract(b2, n) |> each_contract(b3, n)
-                   |> each_contract(b4, n) |> each_contract(b5, n) |> each_contract(b6, n)
-                   |> each_contract(b7, n) |> each_contract(b8, n)
-  end
-
-  defp each_contract(acc, { b1, b2, b3, b4, b5, b6, b7, b8 }, n) do
-    acc |> node_relocate(b1, n) |> node_relocate(b2, n) |> node_relocate(b3, n)
-        |> node_relocate(b4, n) |> node_relocate(b5, n) |> node_relocate(b6, n)
-        |> node_relocate(b7, n) |> node_relocate(b8, n)
-  end
-
-  defp node_relocate(node // @node_template, bucket, n) do
-    :lists.foldl fn { key, value }, acc ->
-      pos = key |> bucket_hash() |> bucket_nth_index(n)
-      set_elem(acc, pos, bucket_put!(elem(acc, pos), key, value))
-    end, node, bucket
-  end
-end
-
-defimpl Enumerable, for: HashDict do
-  def reduce(dict, acc, fun),  do: HashDict.reduce(dict, acc, fun)
-  def member?(dict, { k, v }), do: match?({ :ok, ^v }, HashDict.fetch(dict, k))
-  def member?(_dict, _),       do: false
-  def count(dict),             do: HashDict.size(dict)
-end
-
-defimpl Access, for: HashDict do
-  def access(dict, key), do: HashDict.get(dict, key, nil)
-end
-
-defimpl Binary.Inspect, for: HashDict do
-  import Kernel, except: [inspect: 2]
-
-  def inspect(dict, opts) do
-    "#HashDict<" <> Kernel.inspect(HashDict.to_list(dict), opts) <> ">"
-  end
-end
@@ -1,206 +0,0 @@
-defmodule IO do
-  @moduledoc """
-  Module responsible for doing IO. Many functions in this
-  module expects an IO device and an io data encoded in UTF-8.
-
-  An IO device must be a pid or an atom representing a process.
-  For convenience, Elixir provides `:stdio` and `:stderr` as
-  shortcut to Erlang's `:standard_io` and `:standard_error`.
-
-  An io data can be:
-
-  * A list of integers representing a string. Any unicode
-    character must be represented with one entry in the list,
-    this entry being an integer with the codepoint value;
-
-  * A binary in which unicode characters are represented
-    with many bytes (Elixir's default representation);
-
-  * A list of binaries or a list of char lists (as described above);
-
-  * If none of the above, `to_binary` is invoked in the
-    given argument;
-
-  """
-
-  import :erlang, only: [group_leader: 0]
-
-  @doc """
-  Reads `count` bytes from the IO device. 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 file system.
-  """
-  def read(device // group_leader(), count) do
-    :io.get_chars(map_dev(device), "", count)
-  end
-
-  @doc """
-  Reads `count` bytes from the IO device as binary,
-  no unicode conversion happens.
-
-  Check `read/2` for more information.
-  """
-  def binread(device // group_leader(), count) do
-    case :file.read(map_dev(device), count) do
-      { :ok, data } -> data
-      other -> other
-    end
-  end
-
-  @doc """
-  Reads a line from the IO device. 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 file system.
-
-  This function does the same as `gets/2`,
-  except the prompt is not required as argument.
-  """
-  def readline(device // group_leader()) do
-    :io.get_line(map_dev(device), "")
-  end
-
-  @doc """
-  Reads a line from the IO device as binary,
-  no unicode conversion happens.
-
-  Check `readline/1` for more information.
-  """
-  def binreadline(device // group_leader()) do
-    case :file.read_line(map_dev(device)) do
-      { :ok, data } -> data
-      other -> other
-    end
-  end
-
-  @doc """
-  Writes the given argument to the given device.
-  By default the device is the standard output.
-  The argument is expected to be a chardata (i.e.
-  a char list or an unicode binary).
-
-  It returns `:ok` if it succeeds.
-
-  ## Examples
-
-      IO.write "sample"
-      #=> "sample"
-
-      IO.write :stderr, "error"
-      #=> "error"
-
-  """
-  def write(device // group_leader(), item) do
-    :io.put_chars map_dev(device), to_iodata(item)
-  end
-
-  @doc """
-  Writes the given argument to the given device
-  as a binary, no unicode conversion happens.
-
-  Check `write/2` for more information.
-  """
-  def binwrite(device // group_leader(), item) do
-    :file.write map_dev(device), to_iodata(item)
-  end
-
-  @doc """
-  Writes the argument to the device, similarly to write
-  but adds a new line at the end. The argument is expected
-  to be a chardata.
-  """
-  def puts(device // group_leader(), item) do
-    erl_dev = map_dev(device)
-    :io.put_chars erl_dev, [to_iodata(item), ?\n]
-  end
-
-  @doc """
-  Inspects and writes the given argument to the device
-  followed by a new line. A set of options can be given.
-
-  ## Examples
-
-      IO.inspect Process.list
-
-  """
-  def inspect(item, opts // []) do
-    inspect group_leader(), item, opts
-  end
-
-  @doc """
-  Inspects the item with options using the given device.
-  """
-  def inspect(device, item, opts) do
-    puts device, Kernel.inspect(item, opts)
-    item
-  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, the number of raw bytes. 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 file system.
-  """
-  def getn(prompt, count // 1)
-
-  def getn(prompt, count) when is_integer(count) do
-    getn(group_leader, prompt, count)
-  end
-
-  def getn(device, prompt) do
-    getn(device, prompt, 1)
-  end
-
-  @doc """
-  Gets a number of bytes from the io device. If the
-  io device is a unicode device, count implies
-  the number of unicode codepoints to be retrieved.
-  Otherwise, the number of raw bytes.
-  """
-  def getn(device, prompt, count) do
-    :io.get_chars(map_dev(device), to_iodata(prompt), count)
-  end
-
-  @doc """
-  Reads a line from the IO device. It returns:
-
-  * `data` - The characters in the line terminated
-    by a LF (or end of file).
-
-  * :eof - End of file was encountered.
-
-  * {:error, reason} - Other (rare) error condition,
-    for instance {:error, :estale} if reading from an
-    NFS file system.
-  """
-  def gets(device // group_leader(), prompt) do
-    :io.get_line(map_dev(device), to_iodata(prompt))
-  end
-
-  # 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),   do: other
-
-  defp to_iodata(io) when is_list(io) or is_binary(io), do: io
-  defp to_iodata(other), do: to_binary(other)
-end
@@ -1,218 +0,0 @@
-defmodule IO.ANSI.Sequence do
-  @moduledoc false
-
-  defmacro defsequence(name, code) do
-    quote do
-      name = unquote(name)
-      code = unquote(code)
-
-      def name, [], [], do:
-        quote do: "\e[#{unquote(code)}m"
-
-      args =
-        quote do: [<< unquote(atom_to_binary(name)), rest :: binary >> ]
-
-      defp :escape_sequence, args, [], do:
-        quote do: { "\e[#{unquote(code)}m", rest }
-    end
-  end
-end
-
-defmodule IO.ANSI do
-  @moduledoc """
-  This module provides functionality to render ANSI escape sequences
-  (http://en.wikipedia.org/wiki/ANSI_escape_code) —  characters embedded
-  in the text used to control formatting, color, and other output options
-  on video text terminals.
-  """
-
-  import IO.ANSI.Sequence
-
-  @doc """
-  Checks whether the default I/O device is a terminal or a file.
-
-  Used to identify whether printing ANSI escape sequences will likely
-  be printed as intended.
-  """
-  @spec terminal? :: boolean
-  @spec terminal?(:io.device) :: boolean
-  def terminal?(device // :erlang.group_leader) do
-    match?({:ok, _}, :io.columns(device))
-  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
-
-  lc font_n inlist [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
-
-  colors = [:black, :red, :green, :yellow, :blue, :magenta, :cyan, :white]
-  colors = Enum.zip(0..(length(colors)-1), colors)
-
-  lc { code, color } inlist colors do
-    @doc "Sets foreground color to #{color}"
-    defsequence color, code + 30
-
-    @doc "Sets background color to #{color}"
-    defsequence :"#{color}_background", code + 40
-  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
-
-  # Catch spaces between codes
-  defp escape_sequence(<< ?\s, rest :: binary >>) do
-    escape_sequence(rest)
-  end
-
-  defp escape_sequence(other) do
-    [spec|_] = String.split(other, %r/(,|\})/)
-    raise ArgumentError, message: "invalid ANSI sequence specification: #{spec}"
-  end
-
-  @doc %B"""
-  Escapes a string by converting named ANSI sequences into actual ANSI codes.
-
-  The format for referring to sequences is `%{red}` and `%{red,bright}` (for
-  multiple sequences).
-
-  It will also append a %{reset} to the string. If you don't want this
-  behaviour, use `escape_fragment/1` and `escape_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, standard output will be checked if it is a terminal capable
-  of handling these sequences (using `terminal?/0` function)
-
-  ## Example
-
-    iex> IO.ANSI.escape("Hello %{red,bright,green}yes")
-    "Hello \e[31m\e[1m\e[32myes\e[0m"
-  """
-  @spec escape(String.t, emit :: boolean) :: String.t
-  def escape(string, emit // terminal?) do
-    {rendered, emitted} = do_escape(string, false, emit, false, [])
-    if emitted and emit do
-      rendered <> reset
-    else
-      rendered
-    end
-  end
-
-  @doc %B"""
-  Escapes a string by converting named ANSI sequences into actual ANSI codes.
-
-  The format for referring to sequences is `%{red}` and `%{red,bright}` (for
-  multiple sequences).
-
-  An optional boolean parameter can be passed to enable or disable
-  emitting actual ANSI codes. When false, no ANSI codes will emitted.
-  By default, standard output will be checked if it is a terminal capable
-  of handling these sequences (using `terminal?/0` function)
-
-  ## Example
-
-    iex> IO.ANSI.escape_fragment("Hello %{red,bright,green}yes")
-    "Hello \e[31m\e[1m\e[32myes"
-    iex> IO.ANSI.escape_fragment("%{reset}bye")
-    "\e[0mbye"
-
-  """
-  @spec escape_fragment(String.t, emit :: boolean) :: String.t
-  def escape_fragment(string, emit // terminal?) do
-    {rendered, _emitted} = do_escape(string, false, emit, false, [])
-    rendered
-  end
-
-  defp do_escape(<< ?%, ?{, rest :: binary >>, false, emit, _emitted, acc) do
-    do_escape_sequence(rest, emit, acc)
-  end
-  defp do_escape(<< ?,, rest :: binary >>, true, emit, _emitted, acc) do
-    do_escape_sequence(rest, emit, acc)
-  end
-  defp do_escape(<< ?\s, rest :: binary >>, true, emit, emitted, acc) do
-    do_escape(rest, true, emit, emitted, acc)
-  end
-  defp do_escape(<< ?}, rest :: binary >>, true, emit, emitted, acc) do
-    do_escape(rest, false, emit, emitted, acc)
-  end
-  defp do_escape(<< x :: [binary, size(1)], rest :: binary>>, false, emit, emitted, acc) do
-    do_escape(rest, false, emit, emitted, [x|acc])
-  end
-  defp do_escape("", false, _emit, emitted, acc) do
-    {list_to_binary(Enum.reverse(acc)), emitted}
-  end
-
-  defp do_escape_sequence(rest, emit, acc) do
-    {code, rest} = escape_sequence(rest)
-    if emit do
-      acc = [code|acc]
-    end
-    do_escape(rest, true, emit, true, acc)
-  end
-end
@@ -1,348 +0,0 @@
-defmodule Kernel.CLI do
-  @moduledoc """
-  Module responsible for controlling Elixir's CLI
-  """
-
-  defrecord Config, commands: [], output: ".", compile: [],
-                    halt: true, compiler_options: [], errors: []
-
-  # This is the API invoked by Elixir boot process.
-  @doc false
-  def main(argv) do
-    argv = lc arg inlist argv, do: :unicode.characters_to_binary(arg)
-
-    { config, argv } = process_argv(argv, Kernel.CLI.Config.new)
-    :elixir_code_server.cast({ :argv, argv })
-
-    run fn ->
-      command_results = Enum.map(Enum.reverse(config.commands), process_command(&1, config))
-      command_errors  = lc { :error, msg } inlist command_results, do: msg
-      errors          = Enum.reverse(config.errors) ++ command_errors
-
-      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
-    try do
-      fun.()
-      if halt do
-        at_exit(0)
-        System.halt(0)
-      end
-    rescue
-      exception ->
-        at_exit(1)
-        trace = System.stacktrace
-        IO.puts :stderr, "** (#{inspect exception.__record__(:name)}) #{exception.message}"
-        IO.puts :stderr, Exception.format_stacktrace(trace)
-        System.halt(1)
-    catch
-      :exit, reason when is_integer(reason) ->
-        at_exit(reason)
-        System.halt(reason)
-      :exit, :normal ->
-        at_exit(0)
-        System.halt(0)
-      kind, reason ->
-        at_exit(1)
-        trace = System.stacktrace
-        IO.puts :stderr, "** (#{kind}) #{inspect(reason)}"
-        IO.puts :stderr, Exception.format_stacktrace(trace)
-        System.halt(1)
-    end
-  end
-
-  ## Helpers
-
-  defp at_exit(status) do
-    hooks = :elixir_code_server.call(:flush_at_exit)
-
-    lc hook inlist hooks do
-      try do
-        hook.(status)
-      rescue
-        exception ->
-          trace = System.stacktrace
-          IO.puts :stderr, "** (#{inspect exception.__record__(:name)}) #{exception.message}"
-          IO.puts :stderr, Exception.format_stacktrace(trace)
-      catch
-        kind, reason ->
-          trace = System.stacktrace
-          IO.puts :stderr, "** #{kind} #{inspect(reason)}"
-          IO.puts :stderr, Exception.format_stacktrace(trace)
-      end
-    end
-
-    # If an at_exit callback adds a
-    # new hook we need to invoke it.
-    unless hooks == [], do: at_exit(status)
-  end
-
-  defp shared_option?(list, config, callback) do
-    case process_shared(list, config) do
-      { [h|hs], _ } when h == hd(list) ->
-        new_config = config.update_errors ["#{h} : Unknown option" | &1]
-        callback.(hs, new_config)
-      { new_list, new_config } ->
-        callback.(new_list, new_config)
-    end
-  end
-
-  # Process shared options
-
-  defp process_shared([opt|_t], _config) when opt in ["-v", "--version"] do
-    IO.puts "Elixir #{System.version}"
-    System.halt 0
-  end
-
-  defp process_shared(["-pa",h|t], config) do
-    Enum.each Path.wildcard(Path.expand(h)), Code.prepend_path(&1)
-    process_shared t, config
-  end
-
-  defp process_shared(["-pz",h|t], config) do
-    Enum.each Path.wildcard(Path.expand(h)), Code.append_path(&1)
-    process_shared t, config
-  end
-
-  defp process_shared(["--app",h|t], config) do
-    process_shared t, config.update_commands [{:app,h}|&1]
-  end
-
-  defp process_shared(["--no-halt"|t], config) do
-    process_shared t, config.halt(false)
-  end
-
-  defp process_shared(["-e",h|t], config) do
-    process_shared t, config.update_commands [{:eval,h}|&1]
-  end
-
-  defp process_shared(["-r",h|t], config) do
-    process_shared t, config.update_commands [{:require,h}|&1]
-  end
-
-  defp process_shared(["-pr",h|t], config) do
-    process_shared t, config.update_commands [{:parallel_require,h}|&1]
-  end
-
-  defp process_shared([erl,_|t], config) when erl in ["--erl", "--sname", "--name", "--cookie"] do
-    process_shared t, config
-  end
-
-  defp process_shared(list, config) do
-    { list, config }
-  end
-
-  # Process init options
-
-  defp process_argv(["--"|t], config) do
-    { config, t }
-  end
-
-  defp process_argv(["+compile"|t], config) do
-    process_compiler t, config
-  end
-
-  defp process_argv(["+iex"|t], config) do
-    process_iex t, config
-  end
-
-  defp process_argv(["-S",h|t], config) do
-    { config.update_commands([{:script,h}|&1]), t }
-  end
-
-  defp process_argv([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, process_argv(&1, &2)
-      _ ->
-        { config.update_commands([{:file,h}|&1]), t }
-    end
-  end
-
-  defp process_argv([], config) do
-    { config, [] }
-  end
-
-  # Process compiler options
-
-  defp process_compiler(["--"|t], config) do
-    { config, t }
-  end
-
-  defp process_compiler(["-o",h|t], config) do
-    process_compiler t, config.output(h)
-  end
-
-  defp process_compiler(["--no-docs"|t], config) do
-    process_compiler t, config.update_compiler_options([{:docs,false}|&1])
-  end
-
-  defp process_compiler(["--no-debug-info"|t], config) do
-    process_compiler t, config.update_compiler_options([{:debug_info,false}|&1])
-  end
-
-  defp process_compiler(["--ignore-module-conflict"|t], config) do
-    process_compiler t, config.update_compiler_options([{:ignore_module_conflict,true}|&1])
-  end
-
-  defp process_compiler([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, process_compiler(&1, &2)
-      _ ->
-        pattern = if :filelib.is_dir(h), do: "#{h}/**/*.ex", else: h
-        process_compiler t, config.update_compile [pattern|&1]
-    end
-  end
-
-  defp process_compiler([], config) do
-    { config.update_commands([{:compile,config.compile}|&1]), [] }
-  end
-
-  # Process iex options
-
-  defp process_iex(["--"|t], config) do
-    { config, t }
-  end
-
-  # This clause is here so that Kernel.CLI does not error out with "unknown
-  # option"
-  defp process_iex(["--dot-iex",_|t], config) do
-    process_iex t, config
-  end
-
-  defp process_iex([opt,_|t], config) when opt in ["--remsh"] do
-    process_iex t, config
-  end
-
-  defp process_iex(["-S",h|t], config) do
-    { config.update_commands([{:script,h}|&1]), t }
-  end
-
-  defp process_iex([h|t] = list, config) do
-    case h do
-      "-" <> _ ->
-        shared_option? list, config, process_iex(&1, &2)
-      _ ->
-        { config.update_commands([{:file,h}|&1]), t }
-    end
-  end
-
-  defp process_iex([], config) do
-    { config, [] }
-  end
-
-  # Process commands
-
-  defp process_command({:cookie,h}, _config) do
-    if Node.alive? do
-      Node.set_cookie(binary_to_atom(h))
-      :ok
-    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
-    Code.eval_string(expr, [])
-    :ok
-  end
-
-  defp process_command({:app, app}, _config) when is_binary(app) do
-    case Application.Behaviour.start(binary_to_atom(app)) do
-      { :error, reason } ->
-        { :error, "--app : Could not start application #{app}: #{inspect reason}" }
-      :ok ->
-        :ok
-    end
-  end
-
-  defp process_command({:script, file}, _config) when is_binary(file) do
-    if exec = find_elixir_executable(file) do
-      Code.require_file(exec)
-      :ok
-    else
-      { :error, "-S : Could not find executable #{file}" }
-    end
-  end
-
-  defp process_command({:file, file}, _config) when is_binary(file) do
-    if :filelib.is_regular(file) do
-      Code.require_file(file)
-      :ok
-    else
-      { :error, "No file named #{file}" }
-    end
-  end
-
-  defp process_command({:require, pattern}, _config) when is_binary(pattern) do
-    files = Path.wildcard(pattern)
-    files = Enum.uniq(files)
-    files = Enum.filter files, :filelib.is_regular(&1)
-
-    if files != [] do
-      Enum.map files, Code.require_file(&1)
-      :ok
-    else
-      { :error, "-r : No files matched pattern #{pattern}" }
-    end
-  end
-
-  defp process_command({:parallel_require, pattern}, _config) when is_binary(pattern) do
-    files = Path.wildcard(pattern)
-    files = Enum.uniq(files)
-    files = Enum.filter files, :filelib.is_regular(&1)
-
-    if files != [] do
-      Kernel.ParallelRequire.files(files)
-      :ok
-    else
-      { :error, "-pr : No files matched pattern #{pattern}" }
-    end
-  end
-
-  defp process_command({:compile, patterns}, config) do
-    :filelib.ensure_dir(:filename.join(config.output, "."))
-
-    files = Enum.map patterns, Path.wildcard(&1)
-    files = Enum.uniq(List.concat(files))
-    files = Enum.filter files, :filelib.is_regular(&1)
-
-    if files != [] do
-      Code.compiler_options(config.compiler_options)
-      Kernel.ParallelCompiler.files_to_path(files, config.output,
-        fn file -> IO.puts "Compiled #{file}" end)
-      :ok
-    else
-      { :error, "--compile : No files matched patterns #{Enum.join(patterns, ",")}" }
-    end
-  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, _ } ->
-          exec = Path.rootname(exec)
-          if File.regular?(exec), do: exec
-        _ ->
-          exec
-      end
-    end
-  end
-end
@@ -1,27 +0,0 @@
-# Implement error_handler pattern for Erlang
-# which is integrated with Kernel.ParallelCompiler
-defmodule Kernel.ErrorHandler do
-  @moduledoc false
-
-  def undefined_function(module, fun, args) do
-    ensure_loaded(module)
-    :error_handler.undefined_function(module, fun, args)
-  end
-
-  def undefined_lambda(module, fun, args) do
-    ensure_loaded(module)
-    :error_handler.undefined_lambda(module, fun, args)
-  end
-
-  defp ensure_loaded(module) do
-    case Code.ensure_loaded(module) do
-      { :module, _ } -> []
-      { :error, _ } ->
-        parent = :erlang.get(:elixir_compiler_pid)
-        parent <- { :waiting, self(), module }
-        receive do
-          { :release, ^parent } -> :ok
-        end
-    end
-  end
-end
@@ -1,141 +0,0 @@
-defmodule Kernel.ParallelCompiler do
-  alias :orddict, as: OrdDict
-
-  @moduledoc """
-  A module responsible for compiling files in parallel.
-  """
-
-  defmacrop default_callback, do: quote(do: fn x -> x end)
-
-  @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.
-
-  A callback that is invoked every time a file is compiled
-  with its name can be optionally given as argument.
-  """
-  def files(files, callback // default_callback) do
-    spawn_compilers(files, nil, callback)
-  end
-
-  @doc """
-  Compiles the given files to the given path.
-  Read files/2 for more information.
-  """
-  def files_to_path(files, path, callback // default_callback) when is_binary(path) do
-    spawn_compilers(files, path, callback)
-  end
-
-  defp spawn_compilers(files, path, callback) do
-    Code.ensure_loaded(Kernel.ErrorHandler)
-    schedulers = max(:erlang.system_info(:schedulers_online), 2)
-    spawn_compilers(files, path, callback, [], [], schedulers, [])
-  end
-
-  # We already have 4 currently running, don't spawn new ones
-  defp spawn_compilers(files, output, callback, waiting, queued, schedulers, result) when
-      length(queued) - length(waiting) >= schedulers do
-    wait_for_messages(files, output, callback, waiting, queued, schedulers, result)
-  end
-
-  # Spawn a compiler for each file in the list until we reach the limit
-  defp spawn_compilers([h|t], output, callback, waiting, queued, schedulers, result) do
-    parent = self()
-
-    child  = spawn_link fn ->
-      :erlang.put(:elixir_compiler_pid, parent)
-      :erlang.put(:elixir_ensure_compiled, true)
-      :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-
-      try do
-        if output do
-          :elixir_compiler.file_to_path(h, output)
-        else
-          :elixir_compiler.file(h)
-        end
-        parent <- { :compiled, self(), h }
-      catch
-        kind, reason ->
-          parent <- { :failure, self(), kind, reason, System.stacktrace }
-      end
-    end
-
-    spawn_compilers(t, output, callback, waiting, [{child,h}|queued], schedulers, result)
-  end
-
-  # No more files, nothing waiting, queue is empty, we are done
-  defp spawn_compilers([], _output, _callback, [], [], _schedulers, result), do: result
-
-  # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
-  defp spawn_compilers([], output, callback, waiting, queued, schedulers, result) when length(waiting) == length(queued) do
-    Enum.each queued, fn { child, _ } -> child <- { :release, self() } end
-    wait_for_messages([], output, callback, waiting, queued, schedulers, result)
-  end
-
-  # No more files, but queue and waiting are not full or do not match
-  defp spawn_compilers([], output, callback, waiting, queued, schedulers, result) do
-    wait_for_messages([], output, callback, waiting, queued, schedulers, result)
-  end
-
-  # Wait for messages from child processes
-  defp wait_for_messages(files, output, callback, waiting, queued, schedulers, result) do
-    receive do
-      { :compiled, child, file } ->
-        callback.(file)
-        new_queued  = List.keydelete(queued, child, 0)
-        # Sometimes we may have spurious entries in the waiting
-        # list because someone invoked try/rescue UndefinedFunctionError
-        new_waiting = List.keydelete(waiting, child, 0)
-        spawn_compilers(files, output, callback, new_waiting, new_queued, schedulers, result)
-      { :module_available, _child, module, binary } ->
-        new_waiting = release_waiting_processes(module, waiting)
-        new_result  = [{module, binary}|result]
-        wait_for_messages(files, output, callback, new_waiting, queued, schedulers, new_result)
-      { :waiting, child, on } ->
-        new_waiting = OrdDict.store(child, on, waiting)
-        spawn_compilers(files, output, callback, new_waiting, queued, schedulers, result)
-      { :failure, child, kind, reason, stacktrace } ->
-        if many_missing?(child, files, waiting, queued) do
-          IO.puts "== Compilation failed =="
-          IO.puts "Compilation failed on the following files:\n"
-
-          Enum.each Enum.reverse(queued), fn { pid, file } ->
-            case List.keyfind(waiting, pid, 0) do
-              { _, mod } -> IO.puts "* #{file} is missing module #{inspect mod}"
-              _ -> :ok
-            end
-          end
-
-          IO.puts "\nThe first failure is shown below..."
-        end
-
-        {^child, file} = List.keyfind(queued, child, 0)
-        IO.puts "== Compilation error on file #{file} =="
-        :erlang.raise(kind, reason, stacktrace)
-    end
-  end
-
-  defp many_missing?(child, files, waiting, queued) do
-    waiting_length = length(waiting)
-
-    match?({ ^child, _ }, List.keyfind(waiting, child, 0)) and
-      waiting_length > 1 and files == [] and
-      waiting_length == length(queued)
-  end
-
-  # Release waiting processes that are waiting for the given module
-  defp release_waiting_processes(module, waiting) do
-    Enum.filter waiting, fn { child, waiting_module } ->
-      if waiting_module == module do
-        child <- { :release, self() }
-        false
-      else
-        true
-      end
-    end
-  end
-end
@@ -1,68 +0,0 @@
-defmodule Kernel.ParallelRequire do
-  @moduledoc """
-  A module responsible for requiring files in parallel.
-  """
-
-  defmacrop default_callback, do: quote(do: fn x -> x end)
-
-  @doc """
-  Requires the given files.
-
-  A callback that is invoked every time a file is required
-  can be optionally given as argument.
-  """
-  def files(files, callback // default_callback) do
-    schedulers = max(:erlang.system_info(:schedulers_online), 2)
-    spawn_requires(files, [], callback, schedulers, [])
-  end
-
-  defp spawn_requires([], [], _callback, _schedulers, result), do: result
-
-  defp spawn_requires([], waiting, callback, schedulers, result) do
-    wait_for_messages([], waiting, callback, schedulers, result)
-  end
-
-  defp spawn_requires(files, waiting, callback, schedulers, result) when length(waiting) >= schedulers do
-    wait_for_messages(files, waiting, callback, schedulers, result)
-  end
-
-  defp spawn_requires([h|t], waiting, callback, schedulers, result) do
-    parent = self
-
-    compiler_pid    = :erlang.get(:elixir_compiler_pid)
-    ensure_compiled = :erlang.get(:elixir_ensure_compiled)
-    { :error_handler, handler } = :erlang.process_info(parent, :error_handler)
-
-    child = spawn_link fn ->
-      if compiler_pid != :undefined do
-        :erlang.put(:elixir_compiler_pid, compiler_pid)
-      end
-
-      if ensure_compiled != :undefined do
-        :erlang.put(:elixir_ensure_compiled, ensure_compiled)
-      end
-
-      :erlang.process_flag(:error_handler, handler)
-
-      try do
-        new = Code.require_file(h)
-        parent <- { :required, self, new, h }
-      catch
-        kind, reason ->
-          parent <- { :failure, self, kind, reason, System.stacktrace }
-      end
-    end
-
-    spawn_requires(t, [child|waiting], callback, schedulers, result)
-  end
-
-  defp wait_for_messages(files, waiting, callback, schedulers, result) do
-    receive do
-      { :required, child, new, file } ->
-        callback.(file)
-        spawn_requires(files, List.delete(waiting, child), callback, schedulers, (new || []) ++ result)
-      { :failure, _child, kind, reason, stacktrace } ->
-        :erlang.raise(kind, reason, stacktrace)
-    end
-  end
-end
@@ -1,404 +0,0 @@
-# This is an optimization Elixir runs on function clauses.
-# Whenever a variables matches against a record (a tagged
-# tuple), this information is stored in order to optimize
-# record calls.
-defmodule Kernel.RecordRewriter do
-  @moduledoc false
-
-  def optimize_clause(module, clause) do
-    optimize_clause(clause, module, :orddict.new)
-  end
-
-  ## Clause
-
-  defp optimize_clause({ :clause, line, args, guards, body }, module, dict) do
-    { args, dict } = optimize_args(args, module, dict)
-    { body, dict, res } = optimize_body(body, module, dict, [])
-    { { :clause, line, args, guards, body }, dict, res }
-  end
-
-  defp optimize_args(args, module, dict) do
-    Enum.map_reduce args, dict, fn(arg, acc) ->
-      { new_arg, new_acc, _res } = optimize_expr(arg, module, acc)
-      { new_arg, new_acc }
-    end
-  end
-
-  defp optimize_body([], _module, dict, _acc) do
-    { [], dict, nil }
-  end
-
-  defp optimize_body([h], module, dict, acc) do
-    { new_expr, new_dict, new_res } = optimize_expr(h, module, dict)
-    { Enum.reverse([new_expr|acc]), new_dict, new_res }
-  end
-
-  defp optimize_body([h|t], module, dict, acc) do
-    { new_expr, new_dict, _ } = optimize_expr(h, module, dict)
-    optimize_body(t, module, new_dict, [new_expr|acc])
-  end
-
-  ## Record helpers
-
-  defp record_fields(record, record) do
-    fields      = Module.get_attribute(record, :record_fields)
-    optimizable = Module.get_attribute(record, :record_optimizable)
-    unless nil?(fields) or nil?(optimizable) do
-      { (lc { k, _ } inlist fields, do: k), optimizable }
-    end
-  end
-
-  defp record_fields(_module, record) do
-    if Code.ensure_loaded?(record) && function_exported?(record, :__record__, 1) do
-      try do
-        fields      = lc { k, _ } inlist record.__record__(:fields), do: k
-        optimizable = record.__record__(:optimizable)
-        { fields, optimizable }
-      rescue
-        [UndefinedFunctionError, FunctionClauseError] -> nil
-      end
-    end
-  end
-
-  defp record_field_info(function) do
-    case atom_to_list(function) do
-      'update' -> nil
-      'update_' ++ _field -> nil
-      _ -> { :accessor, function }
-    end
-  end
-
-  defp optimize_call(line, module, { record, _ } = res, left, { :atom, _, function }, args) do
-    case record_fields(module, record) do
-      { fields, optimizable } ->
-        opt_call =
-          if :lists.member({ function, length(args) + 1 }, optimizable) do
-            case record_field_info(function) do
-              { kind, field } ->
-                if index = Enum.find_index(fields, field == &1) do
-                  optimize_record_accessor_call(line, res, kind, field, index, left, args)
-                end
-              nil ->
-                optimize_record_other_call(line, record, res, function, left, args)
-            end
-          end
-
-        opt_call || optimize_record_other_call(line, record, nil, function, left, args)
-      nil ->
-        nil
-    end
-  end
-
-  defp optimize_call(_line, _module, _res, _left, _right, _args) do
-    nil
-  end
-
-  defp optimize_record_accessor_call(line, _res, :accessor, _field, index, left, []) do
-    call = { :call, line,
-      { :remote, line, { :atom, 0, :erlang }, { :atom, 0, :element } },
-      [{ :integer, 0, index + 2 }, left]
-    }
-    { call, nil }
-  end
-
-  defp optimize_record_accessor_call(line, res, :accessor, _field, index, left, [arg]) do
-    call = { :call, line,
-      { :remote, line, { :atom, 0, :erlang }, { :atom, 0, :setelement } },
-      [{ :integer, 0, index + 2 }, left, arg]
-    }
-    { call, res }
-  end
-
-  defp optimize_record_other_call(line, record, res, function, left, args) do
-    call = { :call, line,
-      { :remote, line, { :atom, line, record }, { :atom, 0, function } },
-      args ++ [left]
-    }
-    { call, res }
-  end
-
-  ## Expr
-
-  defp optimize_expr({ :call, call_line, { :remote, line, left, right }, args }, module, dict) do
-    { left, dict, res } = optimize_expr(left, module, dict)
-    { right, dict, _ } = optimize_expr(right, module, dict)
-    { args, dict } = optimize_args(args, module, dict)
-
-    case optimize_call(call_line, module, res, left, right, args) do
-      { call, call_res } ->
-        { call, dict, call_res }
-      nil ->
-        { { :call, call_line, { :remote, line, left, right }, args }, dict, nil }
-    end
-  end
-
-  defp optimize_expr({ :call, line, expr, args }, module, dict) do
-    { expr, dict, _ } = optimize_expr(expr, module, dict)
-    { args, dict } = optimize_args(args, module, dict)
-    { { :call, line, expr, args }, dict, nil }
-  end
-
-  defp optimize_expr({ :match, line, left, right }, module, dict) do
-    { left,  dict, left_res }  = optimize_expr(left, module, dict)
-    { right, dict, right_res } = optimize_expr(right, module, dict)
-
-    match = { :match, line, left, right }
-
-    if left_res do
-      dict = assign_vars(extract_vars(right, []), dict, left_res)
-    end
-
-    if right_res do
-      dict = assign_vars(extract_vars(left, []), dict, right_res)
-    end
-
-    { match, dict, right_res || left_res }
-  end
-
-  defp optimize_expr({ :op, line, op, left, right }, module, dict) do
-    { left, dict, _ }  = optimize_expr(left, module, dict)
-    { right, dict, _ } = optimize_expr(right, module, dict)
-    { { :op, line, op, left, right }, dict, nil }
-  end
-
-  defp optimize_expr({ :op, line, op, expr }, module, dict) do
-    { expr, dict, _ } = optimize_expr(expr, module, dict)
-    { { :op, line, op, expr }, dict, nil }
-  end
-
-  defp optimize_expr({ :bin, line, elements }, module, dict) do
-    { elements, dict } = optimize_args(elements, module, dict)
-    { { :bin, line, elements }, dict, nil }
-  end
-
-  defp optimize_expr({ :bin_element, line, expr, type1, type2 }, module, dict) do
-    { expr, dict, _ } = optimize_expr(expr, module, dict)
-    { { :bin_element, line, expr, type1, type2 }, dict, nil }
-  end
-
-  defp optimize_expr({ :cons, line, left, right }, module, dict) do
-    { left, dict, _ }  = optimize_expr(left, module, dict)
-    { right, dict, _ } = optimize_expr(right, module, dict)
-    { { :cons, line, left, right }, dict, nil }
-  end
-
-  defp optimize_expr({ :block, line, args }, module, dict) do
-    { args, dict, res } = optimize_body(args, module, dict, [])
-    { { :block, line, args }, dict, res }
-  end
-
-  defp optimize_expr({ :tuple, line, args }, module, dict) do
-    { args, dict, args_res } = optimize_tuple_args(args, module, dict)
-    args_res = if Enum.any?(args_res), do: args_res, else: nil
-
-    res =
-      case args do
-        [{ :atom, _, atom }|_] -> atom
-        _ -> nil
-      end
-
-    { { :tuple, line, args }, dict, { res, args_res } }
-  end
-
-  defp optimize_expr({ :var, _, name } = var, _module, dict) do
-    case :orddict.find(name, dict) do
-      { :ok, res } -> { var, dict, res }
-      :error       -> { var, dict, nil }
-    end
-  end
-
-  defp optimize_expr({ :case, line, expr, clauses }, module, dict) do
-    { expr, dict, _ } = optimize_expr(expr, module, dict)
-    tuples  = lc clause inlist clauses, do: optimize_clause(clause, module, dict)
-    clauses = lc { clause, _, _ } inlist tuples, do: clause
-    dict    = join_dict(tuples)
-    res     = join_result(tuples)
-    { { :case, line, expr, clauses }, dict, res }
-  end
-
-  defp optimize_expr({ :receive, line, clauses }, module, dict) do
-    tuples  = lc clause inlist clauses, do: optimize_clause(clause, module, dict)
-    clauses = lc { clause, _, _ } inlist tuples, do: clause
-    dict    = join_dict(tuples)
-    res     = join_result(tuples)
-    { { :receive, line, clauses }, dict, res }
-  end
-
-  defp optimize_expr({ :receive, line, clauses, after_key, after_value }, module, dict) do
-    tuples  = lc clause inlist clauses, do: optimize_clause(clause, module, dict)
-    clauses = lc { clause, _, _ } inlist tuples, do: clause
-
-    { after_key, dict, _ } = optimize_expr(after_key, module, dict)
-    { after_value, dict, res } = optimize_body(after_value, module, dict, [])
-
-    dict = join_dict(tuples, dict)
-    res  = join_result(tuples, res)
-
-    { { :receive, line, clauses, after_key, after_value }, dict, res }
-  end
-
-  defp optimize_expr({ :try, line, body, elses, catches, try_after }, module, dict) do
-    tuples  = lc clause inlist catches, do: optimize_clause(clause, module, dict)
-    catches = lc { clause, _, _ } inlist tuples, do: clause
-
-    tuples  = lc clause inlist elses, do: optimize_clause(clause, module, dict)
-    elses   = lc { clause, _, _ } inlist tuples, do: clause
-
-    { body, _, res } = optimize_body(body, module, dict, [])
-    res = join_result(tuples, res)
-
-    { try_after, _, _ } = optimize_body(try_after, module, dict, [])
-    { { :try, line, body, elses, catches, try_after }, dict, res }
-  end
-
-  defp optimize_expr({ :fun, line, { :function, receiver, name, arity } }, module, dict) do
-    { receiver, dict, _ } = optimize_expr(receiver, module, dict)
-    { name, dict, _ }     = optimize_expr(name, module, dict)
-    { arity, dict, _ }    = optimize_expr(arity, module, dict)
-    { { :fun, line, { :function, receiver, name, arity } }, dict, nil }
-  end
-
-  defp optimize_expr({ :fun, line, { :clauses, clauses } }, module, dict) do
-    clauses = lc clause inlist clauses do
-      { clause, _, _ } = optimize_clause(clause, module, dict)
-      clause
-    end
-
-    { { :fun, line, { :clauses, clauses } }, dict, nil }
-  end
-
-  defp optimize_expr({ comprehension, line, expr, args }, module, dict) when comprehension in [:lc, :bc] do
-    { args, new_dict } = optimize_args(args, module, dict)
-    { expr, _, _ } = optimize_expr(expr, module, new_dict)
-    { { comprehension, line, expr, args }, dict, nil }
-  end
-
-  defp optimize_expr({ generate, line, left, right }, module, dict) when generate in [:generate, :b_generate] do
-    { left, dict, _ }  = optimize_expr(left, module, dict)
-    { right, dict, _ } = optimize_expr(right, module, dict)
-    { { generate, line, left, right }, dict, nil }
-  end
-
-  defp optimize_expr(other, _module, dict) when elem(other, 0) in [:string, :atom, :integer, :float, :nil, :fun] do
-    { other, dict, nil }
-  end
-
-  ## Helpers
-
-  defp optimize_tuple_args(args, module, dict) do
-    { final_args, { final_dict, final_acc } } =
-      Enum.map_reduce args, { dict, [] }, fn(arg, { acc_dict, acc_res }) ->
-        { new_arg, new_acc, res } = optimize_expr(arg, module, acc_dict)
-        { new_arg, { new_acc, [res|acc_res] } }
-      end
-
-    { final_args, final_dict, Enum.reverse(final_acc) }
-  end
-
-  defp assign_vars([key|t], dict, { _, value } = res) when is_list(key) and is_list(value) and length(key) == length(value) do
-    assign_vars t, assign_nested_vars(key, dict, value), res
-  end
-
-  defp assign_vars([key|t], dict, { value, _ } = res) when is_atom(key) and value != nil do
-    dict =
-      case :orddict.find(key, dict) do
-        { :ok, ^res } ->
-          dict
-        { :ok, { ^value, _ } } ->
-          :orddict.store(key, { value, nil }, dict)
-        { :ok, _ } ->
-          # We are overriding a type of an existing variable,
-          # which means the source code is invalid.
-          :orddict.store(key, nil, dict)
-        :error ->
-          :orddict.store(key, res, dict)
-      end
-
-    assign_vars t, dict, res
-  end
-
-  defp assign_vars([_|t], dict, res) do
-    assign_vars t, dict, res
-  end
-
-  defp assign_vars([], dict, _res) do
-    dict
-  end
-
-  defp assign_nested_vars([vars|vt], dict, [res|rt]) do
-    assign_nested_vars(vt, assign_vars(vars, dict, res), rt)
-  end
-
-  defp assign_nested_vars([], dict, []) do
-    dict
-  end
-
-  defp extract_vars({ :match, _, left, right }, vars) do
-    vars = extract_vars(right, vars)
-    extract_vars(left, vars)
-  end
-
-  defp extract_vars({ :var, _, name }, vars) do
-    [name|vars]
-  end
-
-  defp extract_vars({ :tuple, _, args }, vars) do
-    [Enum.map(args, extract_vars(&1, []))|vars]
-  end
-
-  defp extract_vars(_, vars) do
-    vars
-  end
-
-  defp join_dict([]) do
-    []
-  end
-
-  defp join_dict([{ _, dict, _ }|t]) do
-    join_dict(t, dict)
-  end
-
-  defp join_dict([{ _, dict, _ }|t], other) do
-    other = Enum.reduce other, other, fn
-      { key, { value, _ } = res }, acc ->
-        case :orddict.find(key, dict) do
-          { :ok, ^res } -> acc
-          { :ok, { ^value, _ } } -> :orddict.store(key, { value, nil }, acc)
-          { :ok, _ } -> :orddict.store(key, nil, acc)
-          :error -> :orddict.erase(key, acc)
-        end
-      { key, nil }, acc ->
-        :orddict.store(key, nil, acc)
-    end
-
-    join_dict(t, other)
-  end
-
-  defp join_dict([], other) do
-    other
-  end
-
-  defp join_result([]) do
-    []
-  end
-
-  defp join_result([{ _, _, res }|t]) do
-    join_result(t, res)
-  end
-
-  defp join_result([{ _, _, res }|t], res) do
-    join_result(t, res)
-  end
-
-  defp join_result([{ _, _, { res, _ } }|t], { res, _ }) do
-    join_result(t, { res, nil })
-  end
-
-  defp join_result([{ _, _, _ }|_], _res) do
-    nil
-  end
-
-  defp join_result([], res) do
-    res
-  end
-end
@@ -1,819 +0,0 @@
-defmodule Kernel.SpecialForms do
-  @moduledoc """
-  In this module we define Elixir special forms. Special forms
-  cannot be overriden by the developer and are the basic
-  building blocks of Elixir code.
-
-  Some of those forms are lexical (like `alias`, `import`, etc).
-  The macros `{}`, `[]` and `<<>>` are also special forms used
-  to define data structures, respectively tuples, lists and binaries.
-
-  This module also documents Elixir's pseudo variables (`__MODULE__`,
-  `__FILE__`, `__ENV__` and `__CALLER__`). Pseudo variables return
-  information about Elixir's compilation environment and can only
-  be read, never assigned to.
-
-  Finally, it also documents 3 special forms (`__block__`,
-  `__scope__` and `__aliases__`), which are not intended to be
-  called directly by the developer but they appear in quoted
-  contents since they are essential in Elixir's constructions.
-  """
-
-  @doc """
-  Defines a new tuple.
-
-  ## Examples
-
-      iex> { 1, 2, 3 }
-      { 1, 2, 3 }
-
-  """
-  defmacro :{}.(args)
-
-  @doc """
-  Defines a new list.
-
-  ## Examples
-
-      iex> [ 1, 2, 3 ]
-      [ 1, 2, 3 ]
-
-  """
-  defmacro :[].(args)
-
-  @doc """
-  Defines a new bitstring.
-
-  ## Examples
-
-      iex> << 1, 2, 3 >>
-      << 1, 2, 3 >>
-
-  ## Bitstring types
-
-  A bitstring may contain many parts and those may have
-  specific types. Most of the time, Elixir will figure out
-  the part's type and won't require any work from you:
-
-      iex> <<102, "oo">>
-      "foo"
-
-  Above we have two parts: the first is an integer and the
-  second is a binary. If we use any other Elixir expression,
-  Elixir can no longer guess the type:
-
-      iex> rest = "oo"
-      ...> <<102, rest>>
-      ** (ArgumentError) argument error
-
-  When a variable or expression is given as a binary part,
-  Elixir defaults the type of that part to an unsigned
-  little-endian integer. In the example above, since we haven't
-  specified a type, Elixir expected an integer but we passed a
-  binary, resulting in `ArgumentError`. We can solve this by
-  explicitly tagging it as a binary:
-
-      <<102, rest :: binary>>
-
-  The type can be integer, float, binary, bytes, bitstring,
-  bits, utf8, utf16 or utf32, e.g.:
-
-      <<102 :: float, rest :: binary>>
-
-  Integer can be any arbitrary precision integer. A float is an
-  IEEE 754 binary32 or binary64 floating point number. A bitstring
-  is an arbitrary series of bits. A binary is a special case of
-  bitstring that has a total size divisible by 8.
-
-  The utf8, utf16, and utf32 types are for UTF code points.
-
-  The bits type is an alias for bitstring. The bytes type is an
-  alias for binary.
-
-  The signedness can also be given as signed or unsigned. The
-  signedness only matters for matching. If unspecified, it
-  defaults to unsigned. Example:
-
-      iex> <<-100 :: signed, _rest :: binary>> = <<-100, "foo">>
-      <<156,102,111,111>>
-
-  This match would have failed if we did not specify that the
-  value -100 is signed. If we're matching into a variable instead
-  of a value, the signedness won't be checked; rather, the number
-  will simply be interpreted as having the given (or implied)
-  signedness, e.g.:
-
-      iex> <<val, _rest :: binary>> = <<-100, "foo">>
-      ...> val
-      156
-
-  Here, `val` is interpreted as unsigned.
-
-  Signedness is only relevant on integers.
-
-  The endianness of a part can be big, little or native (the
-  latter meaning it will be resolved at VM load time). Passing
-  many options can be done by giving a list:
-
-      <<102 :: [integer, native], rest :: binary>>
-
-  Or:
-
-      <<102 :: [unsigned, big, integer], rest :: binary>>
-
-  And so on.
-
-  Endianness only makes sense for integers and some UTF code
-  point types (utf16 and utf32).
-
-  Finally, we can also specify size and unit for each part. The
-  unit is multiplied by the size to give the effective size of
-  the part:
-
-      iex> <<102, _rest :: [size(2), unit(8)]>> = "foo"
-      "foo"
-
-      iex> <<102, _rest :: size(16)>> = "foo"
-      "foo"
-
-      iex> <<102, _rest :: size(32)>> = "foo"
-      ** (MatchError) no match of right hand side value: "foo"
-
-  In the example above, the first two expressions matches
-  because the string "foo" takes 24 bits and we are matching
-  against a part of 24 bits as well, 8 of which are taken by
-  the integer 102 and the remaining 16 bits are specified on
-  the rest. On the last example, we expect a rest with size 32,
-  which won't match.
-
-  Size and unit are not applicable to utf8, utf16, and utf32.
-
-  The default size for integers is 8. For floats, it is 64. For
-  binaries, it is the size of the binary. Only the last binary
-  in a binary match can use the default size (all others must
-  have their size specified explicitly). Bitstrings do not have
-  a default size.
-
-  Size can also be specified using a syntax shortcut. Instead of
-  writing `size(8)`, one can write just `8` and it will be interpreted
-  as `size(8)`
-
-      iex> << 1 :: 3 >> == << 1 :: size(3) >>
-      true
-
-  The default unit for integers, floats, and bitstrings is 1. For
-  binaries, it is 8.
-
-  For floats, unit * size must result in 32 or 64, corresponding
-  to binary32 and binary64, respectively.
-  """
-  defmacro :<<>>.(args)
-
-  @doc """
-  `alias` is used to setup atom aliases, often useful with modules names.
-
-  ## Examples
-
-  `alias` can be used to setup an alias for any module:
-
-      defmodule Math do
-        alias MyKeyword, as: Keyword
-      end
-
-  In the example above, we have set up `MyKeyword` to be alias
-  as `Keyword`. So now, any reference to `Keyword` will be
-  automatically replaced by `MyKeyword`.
-
-  In case one wants to access the original `Keyword`, it can be done
-  by accessing Elixir:
-
-      Keyword.values   #=> uses MyKeyword.values
-      Elixir.Keyword.values #=> uses Keyword.values
-
-  Notice that calling `alias` without the `as:` option automatically
-  sets an alias based on the last part of the module. For example:
-
-      alias Foo.Bar.Baz
-
-  Is the same as:
-
-      alias Foo.Bar.Baz, as: Baz
-
-  ## Lexical scope
-
-  `import`, `require` and `alias` are called directives and all
-  have lexical scope. This means you can set up aliases inside
-  specific functions and it won't affect the overall scope.
-  """
-  defmacro alias(module, opts)
-
-  @doc """
-  `require` is used to require the presence of external
-  modules so macros can be invoked.
-
-  ## Examples
-
-  Notice that usually modules should not be required before usage,
-  the only exception is if you want to use the macros from a module.
-  In such cases, you need to explicitly require them.
-
-  Let's suppose you created your own `if` implementation in the module
-  `MyMacros`. If you want to invoke it, you need to first explicitly
-  require the `MyMacros`:
-
-      defmodule Math do
-        require MyMacros
-        MyMacros.if do_something, it_works
-      end
-
-  An attempt to call a macro that was not loaded will raise an error.
-
-  ## Alias shortcut
-
-  `require` also accepts `as:` as an option so it automatically sets
-  up an alias. Please check `alias` for more information.
-
-  """
-  defmacro require(module, opts)
-
-  @doc """
-  `import` allows one to easily access functions or macros from
-  others modules without using the qualified name.
-
-  ## Examples
-
-  If you are using several functions from a given module, you can
-  import those functions and reference them as local functions,
-  for example:
-
-      iex> import List
-      ...> flatten([1,[2],3])
-      [1,2,3]
-
-  ## Selector
-
-  By default, Elixir imports functions and macros from the given
-  module, except the ones starting with underscore (which are
-  usually callbacks):
-
-      import List
-
-  A developer can change this behavior to include all macros and
-  functions, regardless if it starts with underscore, by passing
-  `:all` as first argument:
-
-      import :all, List
-
-  It can also be customized to import only all functions or
-  all macros:
-
-      import :functions, List
-      import :macros, List
-
-  Alternatively, Elixir allows a developer to specify `:only`
-  or `:except` as a fine grained control on what to import (or
-  not):
-
-      import List, only: [flatten: 1]
-
-  ## Lexical scope
-
-  It is important to notice that `import` is lexical. This means you
-  can import specific macros inside specific functions:
-
-      defmodule Math do
-        def some_function do
-          # 1) Disable `if/2` from Kernel
-          import Kernel, except: [if: 2]
-
-          # 2) Require the new `if` macro from MyMacros
-          import MyMacros
-
-          # 3) Use the new macro
-          if do_something, it_works
-        end
-      end
-
-  In the example above, we imported macros from `MyMacros`,
-  replacing the original `if/2` implementation by our own
-  during that specific function. All other functions in that
-  module will still be able to use the original one.
-
-  ## Alias/Require shortcut
-
-  All imported modules are also required by default. `import`
-  also accepts `as:` as an option so it automatically sets up
-  an alias. Please check `alias` for more information.
-
-  ## Warnings
-
-  If you import a module and you don't use any of the imported
-  functions or macros from this module, Elixir is going to issue
-  a warning implying the import is not being used.
-
-  In case the import is generated automatically by a macro,
-  Elixir won't emit any warnings though, since the import
-  was not explicitly defined.
-
-  Both warning behaviors could be changed by explicitily
-  setting the `:warn` option to true or false.
-
-  ## Ambiguous function/macro names
-
-  If two modules `A` and `B` are imported and they both contain
-  a `foo` function with an arity of `1`, an error is only emitted
-  if an ambiguous call to `foo/1` is actually made; that is, the
-  errors are emitted lazily, not eagerly.
-  """
-  defmacro import(module, opts)
-
-  @doc """
-  Returns the current environment information as a `Macro.Env`
-  record. In the environment you can access the current filename,
-  line numbers, set up aliases, the current function and others.
-  """
-  defmacro __ENV__
-
-  @doc """
-  Returns the current module name as an atom or nil otherwise.
-  Although the module can be accessed in the __ENV__, this macro
-  is a convenient shortcut.
-  """
-  defmacro __MODULE__
-
-  @doc """
-  Returns the current file name as a binary.
-  Although the file can be accessed in the __ENV__, this macro
-  is a convenient shortcut.
-  """
-  defmacro __FILE__
-
-  @doc """
-  Returns the current directory as a binary.
-  """
-  defmacro __DIR__
-
-  @doc """
-  Allows you to get the representation of any expression.
-
-  ## Examples
-
-      iex> quote do: sum(1, 2, 3)
-      { :sum, [], [1, 2, 3] }
-
-  ## Explanation
-
-  Any Elixir code can be represented using Elixir data structures.
-  The building block of Elixir macros is a tuple with three elements,
-  for example:
-
-      { :sum, [], [1, 2, 3] }
-
-  The tuple above represents a function call to sum passing 1, 2 and
-  3 as arguments. The tuple elements are:
-
-  * The first element of the tuple is always an atom or
-    another tuple in the same representation;
-  * The second element of the tuple represents metadata;
-  * The third element of the tuple are the arguments for the
-    function call. The third argument may be an atom, which is
-    usually a variable (or a local call);
-
-  ## Options
-
-  * `:unquote` - When false, disables unquoting. Useful when you have a quote
-                 inside another quote and want to control which quote is
-                 able to unquote;
-  * `:location` - When set to `:keep`, keeps the current line and file on quotes.
-                  Read the Stacktrace information section below for more information;
-  * `:hygiene` - Allows a developer to disable hygiene selectively;
-  * `:context` - Sets the context resolution happens at;
-
-  ## Macro literals
-
-  Besides the tuple described above, Elixir has a few literals that
-  when quoted return themselves. They are:
-
-      :sum         #=> Atoms
-      1            #=> Integers
-      2.0          #=> Floats
-      [1,2]        #=> Lists
-      "binaries"   #=> Binaries
-      {key, value} #=> Tuple with two elements
-
-  ## Hygiene and context
-
-  Elixir macros are hygienic via means of deferred resolution.
-  This means variables, aliases and imports defined inside the
-  quoted refer to the context that defined the macro and not
-  the context where the macro is expanded.
-
-  For this mechanism to work, every quoted code is attached
-  to a context. Consider the following example:
-
-      defmodule ContextSample do
-        def hello do
-          quote do: world
-        end
-      end
-
-      ContextSample.hello
-      #=> {:world,[],ContextSample}
-
-  Notice how the third element of the returned tuple is the
-  module name. This means that the variable is associated to the
-  ContextSample module and only code generated by this module
-  will be able to access that particular `world` variable.
-  While this means macros from the same module could have
-  conflicting variables, it also allows different quotes from
-  the same module to access them.
-
-  The context can be disabled or changed by explicitly setting
-  the context option. All hygiene mechanisms are based on such
-  context and we are going to explore each of them in the following
-  subsections.
-
-  ### Hygiene in variables
-
-  Consider the following example:
-
-      defmodule Hygiene do
-        defmacro no_interference do
-          quote do: a = 1
-        end
-      end
-
-      require Hygiene
-
-      a = 10
-      Hygiene.no_interference
-      a #=> 10
-
-  In the example above, `a` returns 10 even if the macro
-  is apparently setting it to 1 because variables defined
-  in the macro does not affect the context the macro is executed.
-  If you want to set or get a variable in the user context, you
-  can do it with the help of the `var!` macro:
-
-      defmodule NoHygiene do
-        defmacro interference do
-          quote do: var!(a) = 1
-        end
-      end
-
-      require NoHygiene
-
-      a = 10
-      NoHygiene.interference
-      a #=> 1
-
-  It is important to understand that quoted variables are scoped
-  to the module they are defined. That said, even if two modules
-  define the same quoted variable `a`, their values are going
-  to be independent:
-
-      defmodule Hygiene1 do
-        defmacro var1 do
-          quote do: a = 1
-        end
-      end
-
-      defmodule Hygiene2 do
-        defmacro var2 do
-          quote do: a = 2
-        end
-      end
-
-  Calling macros `var1` and `var2` are not going to change their
-  each other values for `a`. This is useful because quoted
-  variables from different modules cannot conflict. If you desire
-  to explicitly access a variable from another module, we can once
-  again use `var!` macro, but explicitly passing a second argument:
-
-      # Access the variable a from Hygiene1
-      quote do: var!(a, Hygiene1) = 2
-
-  Hygiene for variables can be disabled overall as:
-
-      quote hygiene: [vars: false], do: x
-
-  ### Hygiene in aliases
-
-  Aliases inside quote are hygienic by default.
-  Consider the following example:
-
-      defmodule Hygiene do
-        alias HashDict, as: D
-
-        defmacro no_interference do
-          quote do: D.new
-        end
-      end
-
-      require Hygiene
-      Hygiene.no_interference #=> #HashDict<[]>
-
-  Notice that, even though the alias `D` is not available
-  in the context the macro is expanded, the code above works
-  because `D` still expands to `HashDict`.
-
-  In some particular cases you may want to access an alias
-  or a module defined in the caller. In such scenarios, you
-  can access it by disabling hygiene with `hygiene: [aliases: false]`
-  or by using the `alias!` macro inside the quote:
-
-      defmodule Hygiene do
-        # This will expand to Elixir.Nested.hello
-        defmacro no_interference do
-          quote do: Nested.hello
-        end
-
-        # This will expand to Nested.hello for
-        # whatever is Nested in the caller
-        defmacro interference do
-          quote do: alias!(Nested).hello
-        end
-      end
-
-      defmodule Parent do
-        defmodule Nested do
-          def hello, do: "world"
-        end
-
-        require Hygiene
-        Hygiene.no_interference
-        #=> ** (UndefinedFunctionError) ...
-
-        Hygiene.interference
-        #=> "world"
-      end
-
-
-  ## Hygiene in imports
-
-  Similar to aliases, imports in Elixir hygienic. Consider the
-  following code:
-
-      defmodule Hygiene do
-        defmacrop get_size do
-          quote do
-            size("hello")
-          end
-        end
-
-        def return_size do
-          import Kernel, except: [size: 1]
-          get_size
-        end
-      end
-
-      Hygiene.return_size #=> 5
-
-  Notice how `return_size` returns 5 even though the `size/1`
-  function is not imported.
-
-  Elixir is smart enough to delay the resolution to the latest
-  moment possible. So, if you call `size("hello")` inside quote,
-  but no `size/1` function is available, it is then expanded on
-  the caller:
-
-      defmodule Lazy do
-        defmacrop get_size do
-          import Kernel, except: [size: 1]
-
-          quote do
-            size([a: 1, b: 2])
-          end
-        end
-
-        def return_size do
-          import Kernel, except: [size: 1]
-          import Dict, only: [size: 1]
-          get_size
-        end
-      end
-
-      Lazy.return_size #=> 2
-
-  As in aliases, imports expansion can be explicitly disabled
-  via the `hygiene: [imports: false]` option.
-
-  ## Stacktrace information
-
-  One of Elixir goals is to provide proper stacktrace whenever there is an
-  exception. In order to work properly with macros, the default behavior
-  in quote is to not set a line. When a macro is invoked and the quoted
-  expressions is expanded, the call site line is inserted.
-
-  This is a good behavior for the majority of the cases, except if the macro
-  is defining new functions. Consider this example:
-
-      defmodule MyServer do
-        use GenServer.Behaviour
-      end
-
-  `GenServer.Behaviour` defines new functions in our `MyServer` module.
-  However, if there is an exception in any of these functions, we want
-  the stacktrace to point to the `GenServer.Behaviour` and not the line
-  that calls `use GenServer.Behaviour`. For this reason, there is an
-  option called `:location` that when set to `:keep` keeps the original
-  line and file lines instead of setting them to 0:
-
-      quote location: :keep do
-        def handle_call(request, _from, state) do
-          { :reply, :undef, state }
-        end
-      end
-
-  It is important to warn though that `location: :keep` evaluates the
-  code as if it was defined inside `GenServer.Behaviour` file, in
-  particular, the macro `__FILE__` and exceptions happening inside
-  the quote will always point to `GenServer.Behaviour` file.
-  """
-  defmacro quote(opts, block)
-
-  @doc """
-  When used inside quoting, marks that the variable should
-  not be hygienized. The argument can be either a variable
-  node (i.e. a tuple with three elements where the last
-  one is an atom) or an atom representing the variable name.
-  Check `quote/2` for more information.
-  """
-  defmacro var!(var)
-
-  @doc """
-  Defines a variable in the given context.
-  Check `quote/2` for more information.
-  """
-  defmacro var!(var, context)
-
-  @doc """
-  When used inside quoting, marks that the alias should not
-  be hygienezed. This means the alias will be expanded when
-  the macro is expanded.
-  """
-  defmacro alias!(alias)
-
-  @doc """
-  Unquotes the given expression from inside a macro.
-
-  ## Examples
-
-  Imagine the situation you have a variable `name` and
-  you want to inject it inside some quote. The first attempt
-  would be:
-
-      value = 13
-      quote do: sum(1, value, 3)
-
-  Which would then return:
-
-      { :sum, [], [1, { :value, [], quoted }, 3] }
-
-  Which is not the expected result. For this, we use unquote:
-
-      value = 13
-      quote do: sum(1, unquote(value), 3)
-      #=> { :sum, [], [1, 13, 3] }
-
-  """
-  name = :unquote
-  defmacro unquote(name)(expr)
-
-  @doc """
-  Unquotes the given list expanding its arguments. Similar
-  to unquote.
-
-  ## Examples
-
-      values = [2,3,4]
-      quote do: sum(1, unquote_splicing(values), 5)
-      #=> { :sum, [], [1, 2, 3, 4, 5] }
-
-  """
-  name = :unquote_splicing
-  defmacro unquote(name)(expr)
-
-  @doc """
-  List comprehensions allow you to quickly build a list from another list:
-
-      iex> lc n inlist [1,2,3,4], do: n * 2
-      [2,4,6,8]
-
-  A comprehension accepts many generators and also filters. Generators
-  are defined using both `inlist` and `inbits` operators, allowing you
-  to loop lists and bitstrings:
-
-      # A list generator:
-      iex> lc n inlist [1,2,3,4], do: n * 2
-      [2,4,6,8]
-
-      # A bit string generator:
-      iex> lc <<n>> inbits <<1,2,3,4>>, do: n * 2
-      [2,4,6,8]
-
-      # A generator from a variable:
-      iex> list = [1,2,3,4]
-      ...> lc n inlist list, do: n * 2
-      [2,4,6,8]
-
-      # A comprehension with two generators
-      iex> lc x inlist [1,2], y inlist [2,3], do: x*y
-      [2,3,4,6]
-
-  Filters can also be given:
-
-      # A comprehension with a generator and a filter
-      iex> lc n inlist [1,2,3,4,5,6], rem(n, 2) == 0, do: n
-      [2,4,6]
-
-  Bit string generators are quite useful when you need to
-  organize bit string streams:
-
-      iex> pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>
-      iex> lc <<r::8,g::8,b::8>> inbits pixels, do: {r,g,b}
-      [{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
-
-  """
-  defmacro lc(args)
-
-  @doc """
-  Defines a bit comprehension. It follows the same syntax as
-  a list comprehension but expects each element returned to
-  be a bitstring. For example, here is how to remove all
-  spaces from a string:
-
-      iex> bc <<c>> inbits " hello world ", c != ? , do: <<c>>
-      "helloworld"
-
-  """
-  defmacro bc(args)
-
-  @doc """
-  This is the special form used whenever we have a block
-  of expressions in Elixir. This special form is private
-  and should not be invoked directly:
-
-      iex> quote do: (1; 2; 3)
-      { :__block__, [], [1,2,3] }
-
-  """
-  defmacro __block__(args)
-
-  @doc """
-  This is the special form used whenever we have to temporarily
-  change the scope information of a block. Used when `quote` is
-  invoked with `location: :keep` to execute a given block as if
-  it belonged to another file.
-
-      quote location: :keep, do: 1
-      #=> { :__scope__, [line: 1], [[file: "iex"],[do: 1]] }
-
-  Check `quote/1` for more information.
-  """
-  defmacro __scope__(opts, args)
-
-  @doc """
-  This is the special form used to hold aliases information.
-  It is usually compiled to an atom:
-
-      quote do: Foo.Bar #=>
-      { :__aliases__, [], [:Foo,:Bar] }
-
-  Elixir represents `Foo.Bar` as `__aliases__` so calls can be
-  unambiguously identified by the operator `:.`. For example:
-
-      quote do: Foo.bar #=>
-      {{:.,[],[{:__aliases__,[],[:Foo]},:bar]},[],[]}
-
-  Whenever an expression iterator sees a `:.` as the tuple key,
-  it can be sure that it represents a call and the second argument
-  is the list is an atom.
-
-  On the other hand, aliases holds some properties:
-
-  1) The head element of aliases can be any term;
-
-  2) The tail elements of aliases are guaranteed to always be atoms;
-
-  3) When the head element of aliases is the atom :Elixir, no expansion happen;
-
-  4) When the head element of aliases is not an atom, it is expanded at runtime:
-
-        quote do: some_var.Foo
-        {:__aliases__,[],[{:some_var,[],:quoted},:Bar]}
-
-     Since `some_var` is not available at compilation time, the compiler
-     expands such expression to:
-
-        Module.concat [some_var, Foo]
-
-  """
-  defmacro __aliases__(args)
-
-  @doc """
-  Calls the overriden function when overriding it with `defoverridable`.
-  See `Kernel.defoverridable` for more information and documentation.
-  """
-  defmacro super(args)
-end
@@ -1,737 +0,0 @@
-defmodule Kernel.Typespec do
-  @moduledoc """
-  Holds macros and functions for working with typespecs.
-
-  The attributes `@type`, `@opaque`, `@typep`, `@spec` and
-  `@callback` available in modules are handled by the equivalent
-  macros defined by this module.
-
-  ## Defining a type
-
-  @type type_name :: type
-  @typep type_name :: type
-  @opaque type_name :: type
-
-  For more details, see documentation for deftype, deftypep and defopaque in
-  Kernel.Typespec
-
-  ## Defining a specification
-
-  @spec function_name(type, type) :: type
-  @callback function_name(type, type) :: type
-
-  For more details, see documentation for defspec and defcallback in
-  Kernel.Typespec
-
-  ## Types
-
-  The type syntax provided by Elixir is fairly similar to the one
-  in Erlang.
-
-  Most of the built-in types provided in Erlang (for example, `pid()`)
-  are expressed the same way: `pid()` or simply `pid`. Parametrized types
-  are also supported: `list(integer())` and so are remote types: `Enum.t`.
-
-  Certain data type shortcuts ([...], <<>> and {...}) are supported as well.
-
-  Main differences lie in how bit strings and functions are defined:
-
-  ### Bit Strings
-
-  Bit string with a base size of 3:
-
-      <<_ :: 3>>
-
-  Bit string with a unit size of 8:
-
-      <<_ :: _ * 8>>
-
-  ### Anonymous functions
-
-  Any anonymous function:
-
-      (fun(...) -> any)
-      or
-      ((...) -> any)
-      or
-      (... -> any)
-
-  Anonymous function with arity of zero:
-
-      (fun() -> type)
-      or
-      (() -> type)
-
-  Anonymous function with some arity:
-
-      (fun(type, type) -> type)
-      or
-      ((type, type) -> type)
-      or
-      (type, type -> type)
-
-  ## Notes
-
-  Elixir discourages the use of type `string()` as it might be confused
-  with binaries which are referred to as "strings" in Elixir (as opposed to
-  character lists). In order to use the type that is called `string()` in Erlang,
-  one has to use the `char_list()` type which is a synonym for `string()`. If you
-  use `string()`, you'll get a warning from the compiler.
-
-  If you want to refer to the "string" type (the one operated by functions in the
-  String module), use `String.t()` type instead.
-
-  See http://www.erlang.org/doc/reference_manual/typespec.html
-  for more information.
-  """
-
-  @doc """
-  Defines a type.
-  This macro is the one responsible to handle the attribute @type.
-
-  ## Examples
-
-      @type my_type :: atom
-
-  """
-  defmacro deftype(type) do
-    quote do
-      Kernel.Typespec.deftype(:type, unquote(Macro.escape type), __ENV__)
-    end
-  end
-
-  @doc """
-  Defines an opaque type.
-  This macro is the one responsible to handle the attribute @opaque.
-
-  ## Examples
-
-      @opaque my_type :: atom
-
-  """
-  defmacro defopaque(type) do
-    quote do
-      Kernel.Typespec.deftype(:opaque, unquote(Macro.escape type), __ENV__)
-    end
-  end
-
-  @doc """
-  Defines a private type.
-  This macro is the one responsible to handle the attribute @typep.
-
-  ## Examples
-
-      @typep my_type :: atom
-
-  """
-  defmacro deftypep(type) do
-    quote do
-      Kernel.Typespec.deftype(:typep, unquote(Macro.escape type), __ENV__)
-    end
-  end
-
-  @doc """
-  Defines a spec.
-  This macro is the one responsible to handle the attribute @spec.
-
-  ## Examples
-
-      @spec add(number, number) :: number
-
-  """
-  defmacro defspec(spec) do
-    quote do
-      Kernel.Typespec.defspec(:spec, unquote(Macro.escape spec), __ENV__)
-    end
-  end
-
-  @doc """
-  Defines a callback.
-  This macro is the one responsible to handle the attribute @callback.
-
-  ## Examples
-
-      @callback add(number, number) :: number
-
-  """
-  defmacro defcallback(spec) do
-    quote do
-      Kernel.Typespec.defspec(:callback, unquote(Macro.escape spec), __ENV__)
-    end
-  end
-
-  ## Helpers
-
-  @doc """
-  Defines a `type`, `typep` or `opaque` by receiving Erlang's typespec.
-  """
-  def define_type(module, kind, { name, _, vars } = type) when kind in [:type, :typep, :opaque] do
-    { kind, export } =
-      case kind do
-        :type   -> { :type, true }
-        :typep  -> { :type, false }
-        :opaque -> { :opaque, true }
-      end
-
-    Module.compile_typespec module, kind, type
-    if export, do:
-      Module.compile_typespec module, :export_type, [{ name, length(vars) }]
-    type
-  end
-
-  @doc """
-  Defines a `spec` by receiving Erlang's typespec.
-  """
-  def define_spec(module, tuple, definition) do
-    Module.compile_typespec module, :spec, { tuple, definition }
-  end
-
-  @doc """
-  Defines a `callback` by receiving Erlang's typespec.
-  """
-  def define_callback(module, tuple, definition) do
-    Module.compile_typespec module, :callback, { tuple, definition }
-  end
-
-  @doc """
-  Returns true if the current module defines a given type
-  (private, opaque or not). This function is only available
-  for modules being compiled.
-  """
-  def defines_type?(module, name, arity) do
-    finder = match?({ ^name, _, vars } when length(vars) == arity, &1)
-    :lists.any(finder, Module.get_attribute(module, :type)) or
-      :lists.any(finder, Module.get_attribute(module, :opaque))
-  end
-
-  @doc """
-  Returns true if the current module defines a given spec.
-  This function is only available for modules being compiled.
-  """
-  def defines_spec?(module, name, arity) do
-    tuple = { name, arity }
-    :lists.any(match?(^tuple, &1), Module.get_attribute(module, :spec))
-  end
-
-  @doc """
-  Returns true if the current module defines a callback.
-  This function is only available for modules being compiled.
-  """
-  def defines_callback?(module, name, arity) do
-    tuple = { name, arity }
-    :lists.any(match?(^tuple, &1), Module.get_attribute(module, :callback))
-  end
-
-  @doc """
-  Converts a spec clause back to Elixir AST.
-  """
-  def spec_to_ast(name, { :type, line, :fun, [{:type, _, :product, args},result] }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    { :::, [line: line], [{ name, [line: line], args }, typespec_to_ast(result)] }
-  end
-
-  def spec_to_ast(name, { :type, line, :fun, [] }) do
-    { :::, [line: line], [{ name, [line: line], [] }, quote(do: term)] }
-  end
-
-  def spec_to_ast(name, { :type, line, :bounded_fun, [{ :type, _, :fun, [{ :type, _, :product, args }, result] }, constraints] }) do
-    [h|t] =
-      lc {:type, line, :constraint, [{:atom, _, :is_subtype}, [var, type]]} inlist constraints do
-        { :is_subtype, [line: line], [typespec_to_ast(var), typespec_to_ast(type)] }
-      end
-
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    guards = Enum.reduce t, h, fn(x, acc) -> { :and, line, [acc, x] } end
-
-    { :::, [line: line], [{ :when, [line: line], [{ name, [line: line], args }, guards] }, typespec_to_ast(result)] }
-  end
-
-  @doc """
-  Converts a type clause back to Elixir AST.
-  """
-  def type_to_ast({ { :record, record }, fields, args }) when is_atom(record) do
-    fields = lc field inlist fields, do: typespec_to_ast(field)
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    type = { :{}, [], [record|fields] }
-    quote do: unquote(record)(unquote_splicing(args)) :: unquote(type)
-  end
-
-  def type_to_ast({ name, type, args }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    quote do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_ast(type))
-  end
-
-  @doc """
-  Returns all types available from the beam.
-
-  It is returned as a list of tuples where the first
-  element is the type (`:typep`, `:type` and `:opaque`).
-
-  The module has to have a corresponding beam file
-  on the file system.
-  """
-  def beam_types(module) do
-    case abstract_code(module) do
-      { :ok, abstract_code } ->
-        exported_types = lc { :attribute, _, :export_type, types } inlist abstract_code, do: types
-        exported_types = List.flatten(exported_types)
-
-        lc { :attribute, _, kind, { name, _, args } = type } inlist abstract_code, kind in [:opaque, :type] do
-          cond do
-            kind == :opaque -> { :opaque, type }
-            :lists.member({ name, length(args) }, exported_types) -> { :type, type }
-            true -> { :typep, type }
-          end
-        end
-      _ ->
-        []
-    end
-  end
-
-  @doc """
-  Returns all specs available from the beam.
-
-  It is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module has to have a corresponding beam file
-  on the file system.
-  """
-  def beam_specs(module) do
-    from_abstract_code(module, :spec)
-  end
-
-  @doc """
-  Returns all callbacks available from the beam.
-
-  It is returned as a list of tuples where the first
-  element is spec name and arity and the second is the spec.
-
-  The module has to have a corresponding beam file
-  on the file system.
-  """
-  def beam_callbacks(module) do
-    from_abstract_code(module, :callback)
-  end
-
-  defp from_abstract_code(module, kind) do
-    case abstract_code(module) do
-      { :ok, abstract_code } ->
-        lc { :attribute, _, abs_kind, value } inlist abstract_code, kind == abs_kind, do: value
-      _ ->
-        []
-    end
-  end
-
-  defp abstract_code(module) do
-    case :beam_lib.chunks(abstract_code_beam(module), [:abstract_code]) do
-      {:ok, { _, [{ :abstract_code, { _raw_abstract_v1, abstract_code } }] } } ->
-        { :ok, abstract_code }
-      _ ->
-        []
-    end
-  end
-
-  defp abstract_code_beam(module) when is_atom(module) do
-    case :code.get_object_code(module) do
-      { ^module, beam, _filename } -> beam
-      :error -> module
-    end
-  end
-
-  defp abstract_code_beam(binary) when is_binary(binary) do
-    binary
-  end
-
-  ## Macro callbacks
-
-  @doc false
-  def deftype(kind, { :::, _, [type, definition] }, caller) do
-    do_deftype(kind, type, definition, caller)
-  end
-
-  def deftype(kind, {name, _meta, args} = type, caller)
-      when is_atom(name) and not is_list(args) do
-    do_deftype(kind, type, { :term, [line: caller.line], nil }, caller)
-  end
-
-  def deftype(_kind, other, _caller) do
-    type_spec = Macro.to_binary(other)
-    raise ArgumentError, message: "invalid type specification #{type_spec}"
-  end
-
-  defp do_deftype(kind, { name, _, args }, definition, caller) do
-    args =
-      if is_atom(args) do
-        []
-      else
-        lc(arg inlist args, do: variable(arg))
-      end
-
-    vars = lc { :var, _, var } inlist args, do: var
-    spec = typespec(definition, vars, caller)
-
-    vars = lc { :var, _, _ } = var inlist args, do: var
-    type = { name, spec, vars }
-
-    define_type(caller.module, kind, type)
-  end
-
-  @doc false
-  def defspec(type, {:::, _, [{ :when, _, [{ name, meta, args }, constraints_guard] }, return] }, caller) do
-    if is_atom(args), do: args = []
-    constraints = guard_to_constraints(constraints_guard, caller)
-    spec = { :type, line(meta), :fun, fn_args(meta, args, return, Keyword.keys(constraints), caller) }
-    spec = { :type, line(meta), :bounded_fun, [spec, Keyword.values(constraints)] }
-    code = { { name, Kernel.length(args) }, spec }
-    Module.compile_typespec(caller.module, type, code)
-    code
-  end
-
-  def defspec(type, {:::, _, [{ name, meta, args }, return]}, caller) do
-    if is_atom(args), do: args = []
-    spec = { :type, line(meta), :fun, fn_args(meta, args, return, [], caller) }
-    code = { { name, Kernel.length(args) }, spec }
-    Module.compile_typespec(caller.module, type, code)
-    code
-  end
-
-  def defspec(_type, other, _caller) do
-    spec = Macro.to_binary(other)
-    raise ArgumentError, message: "invalid function type specification #{spec}"
-  end
-
-  defp guard_to_constraints({ :is_subtype, meta, [{ name, _, _ }, type] }, caller) do
-    line = line(meta)
-    contraints = [{ :atom, line, :is_subtype }, [{:var, line, name}, typespec(type, [], caller)]]
-    [{ name, { :type, line, :constraint, contraints } }]
-  end
-
-  defp guard_to_constraints({ :and, _, [left, right] }, caller) do
-    guard_to_constraints(left, caller) ++ guard_to_constraints(right, caller)
-  end
-
-  ## To AST conversion
-
-  defp typespec_to_ast({ :type, line, :tuple, :any }) do
-    typespec_to_ast({:type, line, :tuple, []})
-  end
-
-  defp typespec_to_ast({ :type, line, :tuple, args }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    { :{}, [line: line], args }
-  end
-
-  defp typespec_to_ast({ :type, _line, :list, [arg] }) do
-    case unpack_typespec_kw(arg, []) do
-      { :ok, ast } -> ast
-      :error -> [typespec_to_ast(arg)]
-    end
-  end
-
-  defp typespec_to_ast({ :type, _line, :list, args }) do
-    lc arg inlist args, do: typespec_to_ast(arg)
-  end
-
-  defp typespec_to_ast({ :type, line, :binary, [arg1, arg2] }) do
-    [arg1, arg2] = lc arg inlist [arg1, arg2], do: typespec_to_ast(arg)
-    cond do
-      arg2 == 0 ->
-        quote line: line, do: <<_ :: unquote(arg1)>>
-      arg1 == 0 ->
-        quote line: line, do: <<_ :: _ * unquote(arg2)>>
-      true ->
-        quote line: line, do: <<_ :: unquote(arg1) * unquote(arg2)>>
-    end
-  end
-
-  defp typespec_to_ast({ :type, line, :union, args }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    Enum.reduce tl(args), hd(args),
-      fn(arg, expr) -> { :|, [line: line], [expr, arg] } end
-  end
-
-  defp typespec_to_ast({ :type, line, :fun, [{:type, _, :product, args},result] }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    { :"->", [line: line], [{args, typespec_to_ast(result)}] }
-  end
-
-  defp typespec_to_ast({ :type, line, :fun, [args, result] }) do
-    { :"->", [line: line], [{[typespec_to_ast(args)], typespec_to_ast(result)}] }
-  end
-
-  defp typespec_to_ast({ :type, line, :fun, [] }) do
-    typespec_to_ast({ :type, line, :fun, [{:type, line, :any}, {:type,line,:any, []} ] })
-  end
-
-  defp typespec_to_ast({ :type, line, :range, [left, right] }) do
-    { :"..", [line: line], [typespec_to_ast(left), typespec_to_ast(right)] }
-  end
-
-  defp typespec_to_ast({ :type, line, name, args }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    { name, [line: line], args }
-  end
-
-  defp typespec_to_ast({ :var, line, var }) do
-    var =
-    case atom_to_binary(var) do
-      <<"_", c :: [binary, size(1)], rest :: binary>> ->
-        binary_to_atom("_#{String.downcase(c)}#{rest}")
-      <<c :: [binary, size(1)], rest :: binary>> ->
-        binary_to_atom("#{String.downcase(c)}#{rest}")
-    end
-    { var, line, nil }
-  end
-
-  # Special shortcut(s)
-  defp typespec_to_ast({ :remote_type, line, [{:atom, _, :elixir}, {:atom, _, :char_list}, []] }) do
-    typespec_to_ast({:type, line, :char_list, []})
-  end
-
-  defp typespec_to_ast({ :remote_type, line, [{:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]] }) do
-    typespec_to_ast({:type, line, :as_boolean, [arg]})
-  end
-
-  defp typespec_to_ast({ :remote_type, line, [mod, name, args] }) do
-    args = lc arg inlist args, do: typespec_to_ast(arg)
-    dot  = { :., [line: line], [typespec_to_ast(mod), typespec_to_ast(name)] }
-    { dot, [line: line], args }
-  end
-
-  defp typespec_to_ast({ :ann_type, line, [var, type] }) do
-    { :::, [line: line], [typespec_to_ast(var), typespec_to_ast(type)] }
-  end
-
-  defp typespec_to_ast({ :typed_record_field,
-                         { :record_field, line, { :atom, line1, name }},
-                         type }) do
-    typespec_to_ast({ :ann_type, line, [{ :var, line1, name }, type] })
-  end
-
-  defp typespec_to_ast({:type, _, :any}) do
-    quote do: ...
-  end
-
-  defp typespec_to_ast({:paren_type, _, [type]}) do
-    typespec_to_ast(type)
-  end
-
-  defp typespec_to_ast({ t, _line, atom }) when is_atom(t) do
-    atom
-  end
-
-  defp typespec_to_ast(other), do: other
-
-  ## From AST conversion
-
-  defp line(meta) do
-    case :lists.keyfind(:line, 1, meta) do
-      { :line, line } -> line
-      false -> 0
-    end
-  end
-
-  # Handle unions
-  defp typespec({ :|, meta, [_,_] } = exprs, vars, caller) do
-    exprs = Enum.reverse(collect_union(exprs))
-    union = lc e inlist exprs, do: typespec(e, vars, caller)
-    { :type, line(meta), :union, union }
-  end
-
-  # Handle binaries
-  defp typespec({:<<>>, meta, []}, _,_) do
-    {:type, line(meta), :binary, [{:integer, line(meta), 0}, {:integer, line(meta), 0}]}
-  end
-
-  defp typespec({:<<>>, meta, [{:::, _, [{:_, meta1, atom}, {:*, _, [{:_, meta2, atom}, unit]}]}]}, _, _) when is_atom(atom) do
-    {:type, line(meta), :binary, [{:integer, line(meta1), 0}, {:integer, line(meta2), unit}]}
-  end
-
-  defp typespec({:<<>>, meta, [{:::, meta1, [{:_, meta2, atom}, base]}]}, _, _) when is_atom(atom) do
-    {:type, line(meta), :binary, [{:integer, line(meta1), base}, {:integer, line(meta2), 0}]}
-  end
-
-  # Handle ranges
-  defp typespec({:"..", meta, args}, vars, caller) do
-    typespec({:range, meta, args}, vars, caller)
-  end
-
-  # Handle special forms
-  defp typespec({:__MODULE__, _, atom}, vars, caller) when is_atom(atom) do
-    typespec(caller.module, vars, caller)
-  end
-
-  defp typespec({:__aliases__, _, _} = alias, vars, caller) do
-    atom = Macro.expand alias, caller
-    typespec(atom, vars, caller)
-  end
-
-  # Handle funs
-  defp typespec({:->, meta, [{[{:fun, _, arguments}], return}]}, vars, caller) when is_list(arguments) do
-    typespec({:->, meta, [{arguments, return}]}, vars, caller)
-  end
-
-  defp typespec({:->, meta, [{arguments, return}]}, vars, caller) when is_list(arguments) do
-    args = fn_args(meta, arguments, return, vars, caller)
-    { :type, line(meta), :fun, args }
-  end
-
-  # Handle type operator
-  defp typespec({:"::", meta, [var, expr] }, vars, caller) do
-    left  = typespec(var, [elem(var, 0)|vars], caller)
-    right = typespec(expr, vars, caller)
-    { :ann_type, line(meta), [left, right] }
-  end
-
-  # Handle unary ops
-  defp typespec({op, meta, [integer]}, _, _) when op in [:+, :-] and is_integer(integer) do
-    { :op, line(meta), op, {:integer, line(meta), integer} }
-  end
-
-  # Handle access macro
-  defp typespec({{:., meta, [Kernel, :access]}, meta1, [target, args]}, vars, caller) do
-    access = {{:., meta, [Kernel, :access]}, meta1,
-              [target, args ++ [_: { :any, [], [] }]]}
-    typespec(Macro.expand(access, caller), vars, caller)
-  end
-
-  # Handle remote calls
-  defp typespec({{:., meta, [remote, name]}, _, args}, vars, caller) do
-    remote = Macro.expand remote, caller
-    unless is_atom(remote), do: raise ArgumentError, message: "invalid remote in typespec"
-    remote_type({typespec(remote, vars, caller), meta, typespec(name, vars, caller), args}, vars, caller)
-  end
-
-  # Handle tuples
-  defp typespec({:tuple, meta, atom}, vars, caller) when is_atom(atom) do
-    typespec({:{}, meta, []}, vars, caller)
-  end
-
-  defp typespec({:{}, meta, []}, _, _) do
-    { :type, line(meta), :tuple, :any }
-  end
-
-  defp typespec({:{}, meta, t}, vars, caller) when is_list(t) do
-    args = lc e inlist t, do: typespec(e, vars, caller)
-    { :type, line(meta), :tuple, args }
-  end
-
-  # Handle blocks
-  defp typespec({:__block__, _meta, [arg]}, vars, caller) do
-    typespec(arg, vars, caller)
-  end
-
-  # Handle variables or local calls
-  defp typespec({name, meta, atom}, vars, caller) when is_atom(atom) do
-    if :lists.member(name, vars) do
-      { :var, line(meta), name }
-    else
-      typespec({name, meta, []}, vars, caller)
-    end
-  end
-
-  # Handle local calls
-  defp typespec({:string, meta, arguments}, vars, caller) do
-    IO.write "warning: string() type use is discouraged. For character lists, use " <>
-      "char_list() type, for strings, String.t()\n#{Exception.format_stacktrace(caller.stacktrace)}"
-    arguments = lc arg inlist arguments, do: typespec(arg, vars, caller)
-    { :type, line(meta), :string, arguments }
-  end
-
-  defp typespec({:char_list, _meta, arguments}, vars, caller) do
-    typespec((quote do: :elixir.char_list(unquote_splicing(arguments))), vars, caller)
-  end
-
-  defp typespec({:as_boolean, _meta, arguments}, vars, caller) do
-    typespec((quote do: :elixir.as_boolean(unquote_splicing(arguments))), vars, caller)
-  end
-
-  defp typespec({name, meta, arguments}, vars, caller) do
-    arguments = lc arg inlist arguments, do: typespec(arg, vars, caller)
-    { :type, line(meta), name, arguments }
-  end
-
-  # Handle literals
-  defp typespec(atom, _, _) when is_atom(atom) do
-    { :atom, 0, atom }
-  end
-
-  defp typespec(integer, _, _) when is_integer(integer) do
-    { :integer, 0, integer }
-  end
-
-  defp typespec([], vars, caller) do
-    typespec({ nil, [], [] }, vars, caller)
-  end
-
-  defp typespec([spec], vars, caller) do
-    typespec({ :list, [], [spec] }, vars, caller)
-  end
-
-  defp typespec([spec, {:"...", _, quoted}], vars, caller) when is_atom(quoted) do
-    typespec({ :nonempty_list, [], [spec] }, vars, caller)
-  end
-
-  defp typespec([h|t] = l, vars, caller) do
-    union = Enum.reduce(t, validate_kw(h, l), fn(x, acc) ->
-      { :|, [], [acc, validate_kw(x, l)] }
-    end)
-    typespec({ :list, [], [union] }, vars, caller)
-  end
-
-  defp typespec(t, vars, caller) when is_tuple(t) do
-    args = lc e inlist tuple_to_list(t), do: typespec(e, vars, caller)
-    { :type, 0, :tuple, args }
-  end
-
-  ## Helpers
-
-  defp remote_type({remote, meta, name, arguments}, vars, caller) do
-    arguments = lc arg inlist arguments, do: typespec(arg, vars, caller)
-    { :remote_type, line(meta), [ remote, name, arguments ] }
-  end
-
-  defp collect_union({ :|, _, [a, b] }), do: [b|collect_union(a)]
-  defp collect_union(v), do: [v]
-
-  defp validate_kw({ key, _ } = t, _) when is_atom(key), do: t
-  defp validate_kw(_, original) do
-    raise ArgumentError, message: "unexpected list #{inspect original} in typespec"
-  end
-
-  defp fn_args(meta, args, return, vars, caller) do
-    case [fn_args(meta, args, vars, caller), typespec(return, vars, caller)] do
-      [{:type,_,:any},{:type,_,:any,[]}] -> []
-      x -> x
-    end
-  end
-
-  defp fn_args(meta, [{:"...", _, _}], _vars, _caller) do
-    { :type, line(meta), :any }
-  end
-
-  defp fn_args(meta, args, vars, caller) do
-    args = lc arg inlist args, do: typespec(arg, vars, caller)
-    { :type, line(meta), :product, args }
-  end
-
-  defp variable({name, meta, _}) do
-    {:var, line(meta), name}
-  end
-
-  defp unpack_typespec_kw({ :type, _, :union, [
-         next,
-         { :type, _, :tuple, [{ :atom, _, atom }, type] }
-       ] }, acc) do
-    unpack_typespec_kw(next, [{atom,typespec_to_ast(type)}|acc])
-  end
-
-  defp unpack_typespec_kw({ :type, _, :tuple, [{ :atom, _, atom }, type] }, acc) do
-    { :ok, [{atom,typespec_to_ast(type)}|acc] }
-  end
-
-  defp unpack_typespec_kw(_, _acc) do
-    :error
-  end
-end
@@ -1,394 +0,0 @@
-defmodule Keyword do
-  @moduledoc """
-  A keyword is a list of tuples where the first element
-  of the tuple is an atom and the second element can be
-  any value.
-
-  A keyword may have duplicated keys, so it is not strictly
-  a dictionary. However most of the functions in this module
-  allows it to behave exactly as a dictionary. For example,
-  `Keyword.get` will get the first entry matching the given
-  key, regardless if duplicated entries exist. Similarly,
-  `Keyword.put` and `Keyword.delete` ensure all duplicated
-  entries for a given key are removed when invoked.
-  """
-
-  @type key :: atom
-  @type value :: any
-  @type t :: [{key, value}]
-
-  @doc """
-  Creates a Keyword from enum. Differently from `Keyword.new`
-  which behaves as a dict, `Keyword.from_enum` do not remove
-  duplicated entries.
-  """
-  @spec from_enum(Enum.t) :: t
-  def from_enum(enum) when is_list(enum) do
-    enum
-  end
-
-  def from_enum(enum) do
-    Enum.map(enum, fn(x) -> x end)
-  end
-
-  @doc """
-  Checks if the given argument is a keywords list or not
-  """
-  @spec keyword?(term) :: boolean
-  def keyword?([{ key, _value } | rest]) when is_atom(key) do
-    keyword?(rest)
-  end
-
-  def keyword?([]),     do: true
-  def keyword?(_other), do: false
-
-  @doc """
-  Returns an empty keyword list, i.e. an empty list.
-  """
-  @spec new :: t
-  def new do
-    []
-  end
-
-  @doc """
-  Creates a Keyword from an enumerable. Similarly to dicts,
-  duplicated entries are removed, the latest one prevails.
-
-  ## Examples
-
-      iex> Keyword.new([{:b,1},{:a,2}])
-      [a: 2, b: 1]
-
-  """
-  @spec new(Enum.t) :: t
-  def new(pairs) do
-    Enum.reduce pairs, [], fn { k, v }, keywords ->
-      put(keywords, k, v)
-    end
-  end
-
-  @doc """
-  Creates a Keyword from an enumerable with the
-  help of the transformation function. Duplicated
-  entries are removed, the latest one prevails.
-
-  ## Examples
-
-      iex> Keyword.new([:a, :b], fn (x) -> {x,x} end) |> Enum.sort
-      [a: :a, b: :b]
-
-  """
-  @spec new(Enum.t, ({key, value} -> {key, value})) :: t
-  def new(pairs, transform) do
-    Enum.reduce pairs, [], fn i, keywords ->
-      { k, v } = transform.(i)
-      put(keywords, k, v)
-    end
-  end
-
-  @doc """
-  Gets the value for specific key.
-
-  If key not exist return default value (nil if no default value)
-  exists.
-
-  If duplicated entries exist, the first one is returned.
-  Use get_values/2 to retrieve all entries.
-
-  ## Examples
-
-      iex> Keyword.get([a: 1], :a)
-      1
-      iex> Keyword.get([a: 1], :b)
-      nil
-      iex> Keyword.get([a: 1], :b, 3)
-      3
-
-  """
-  @spec get(t, key) :: value
-  @spec get(t, key, value) :: value
-  def get(keywords, key, default // nil) when is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      { ^key, value } -> value
-      false -> default
-    end
-  end
-
-  @doc """
-  Fetchs the value for specific key and return 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) :: value
-  def fetch(keywords, key) when 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,
-  an error is raised.
-
-  ## Examples
-
-      iex> Keyword.fetch!([a: 1], :a)
-      1
-
-      iex> Keyword.fetch!([a: 1], :b)
-      ** (KeyError) key not found: :b
-
-  """
-  @spec fetch!(t, key) :: value | no_return
-  def fetch!(keywords, key) when is_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      { ^key, value } -> value
-      false -> raise(KeyError, key: key)
-    end
-  end
-
-  @doc """
-  Gets all values for a specific key.
-
-  ## Examples
-
-      iex> Keyword.get_values([a: 1, a: 2], :a)
-      [1,2]
-
-  """
-  @spec get_values(t, key) :: [value]
-  def get_values(keywords, key) when is_atom(key) do
-    lc { k, v } inlist keywords, key == k, do: v
-  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]
-
-  """
-  @spec keys(t) :: [key]
-  def keys(keywords) do
-    lc { key, _ } inlist keywords, do: key
-  end
-
-  @doc """
-  Returns all values.
-
-  ## Examples
-
-      iex> Keyword.values([a: 1, b: 2])
-      [1,2]
-
-  """
-  @spec values(t) :: [value]
-  def values(keywords) do
-    lc { _, value } inlist keywords, do: value
-  end
-
-  @doc """
-  Deletes all entries in the keyword list for a specific key.
-  If the key does not exist, returns the keyword list unchanged.
-  Use `delete_first` 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([b: 2], :a)
-      [b: 2]
-
-  """
-  @spec delete(t, key) :: t
-  def delete(keywords, key) when is_atom(key) do
-    lc { k, _ } = tuple inlist keywords, key != k, do: tuple
-  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_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 overriden.
-
-  ## Examples
-
-      iex> Keyword.put([a: 1, b: 2], :a, 3)
-      [a: 3, b: 2]
-
-  """
-  @spec put(t, key, value) :: t
-  def put(keywords, key, value) when is_atom(key) do
-    [{key, value}|delete(keywords, key)]
-  end
-
-  @doc """
-  Puts the given `value` under `key` unless the entry `key`
-  already exists.
-
-  ## Examples
-
-      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_atom(key) do
-    case :lists.keyfind(key, 1, keywords) do
-      { ^key, _ } -> keywords
-      false -> [{key,value}|keywords]
-    end
-  end
-
-  @doc """
-  Checks if two keywords are equal. I.e. 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
-
-  """
-  @spec equal?(t, t) :: boolean
-  def equal?(left, right) do
-    :lists.sort(left) == :lists.sort(right)
-  end
-
-  @doc """
-  Merges two keyword lists into one. If they have duplicated
-  entries, the one given as second argument wins.
-
-  ## Examples
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4]) |> Enum.sort
-      [a: 3, b: 2, d: 4]
-
-  """
-  @spec merge(t, t) :: t
-  def merge(d1, d2) do
-    d2 ++ lc({ k, _ } = tuple inlist d1, not has_key?(d2, k), do: tuple)
-  end
-
-  @doc """
-  Merges two keyword lists into one. If they have duplicated
-  entries, the given function is invoked to solve conflicts.
-
-  ## Examples
-
-      iex> Keyword.merge([a: 1, b: 2], [a: 3, d: 4], fn (_k, v1, v2) ->
-      ...>  v1 + v2
-      iex> end)
-      [a: 4, b: 2, d: 4]
-
-  """
-  @spec merge(t, t, (key, value, value -> value)) :: t
-  def merge(d1, d2, fun) do
-    do_merge(d2, d1, fun)
-  end
-
-  defp do_merge([{ k, v2 }|t], acc, fun) do
-    do_merge t, update(acc, k, v2, fn(v1) -> fun.(k, v1, v2) end), fun
-  end
-
-  defp do_merge([], acc, _fun) do
-    acc
-  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_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`.
-
-  ## Examples
-
-      iex> Keyword.update([a: 1], :a, &1 * 2)
-      [a: 2]
-
-      iex> Keyword.update([a: 1], :b, &1 * 2)
-      ** (KeyError) key not found: :b
-
-  """
-  @spec update(t, key, (value -> value)) :: t | no_return
-  def update([{key, value}|keywords], key, fun) do
-    [{key, fun.(value)}|delete(keywords, key)]
-  end
-
-  def update([{_, _} = e|keywords], key, fun) do
-    [e|update(keywords, key, fun)]
-  end
-
-  def update([], key, _fun) when is_atom(key) do
-    raise(KeyError, key: key)
-  end
-
-  @doc """
-  Updates the key with the given function. If the key does
-  not exist, inserts the given `initial` value.
-
-  ## Examples
-
-      iex> Keyword.update([a: 1], :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([{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
-end
@@ -1,361 +0,0 @@
-defmodule List do
-  @moduledoc """
-  Implements functions that only make sense for lists
-  and cannot be part of the Enum protocol. In general,
-  favor using the Enum API instead of List.
-
-  A decision was taken to delegate most functions to
-  Erlang's standard lib but following Elixir's convention
-  of receiving the target (in this case, a list) as the
-  first argument.
-  """
-
-  @doc """
-  Given a list of lists, concatenates the sublists into a single list.
-
-  ## Examples
-
-      iex> List.concat([[1,[2],3], [4], [5,6]])
-      [1,[2],3,4,5,6]
-
-  """
-  def concat(list) when is_list(list) do
-    :lists.append(list)
-  end
-
-  @doc """
-  Concatenates the list on the right with the list on the left.
-
-  This function produces the same result the `++` operator. The only difference
-  is a minor optimization: when the first list contains only one element, we
-  simply add it as a head to the second list.
-
-  ## Examples
-
-      iex> List.concat([1,2,3], [4,5,6])
-      [1,2,3,4,5,6]
-
-  """
-  def concat(list, elements) when is_list(list) and is_list(elements) do
-    list ++ elements
-  end
-
-  @doc """
-  Deletes the given item from the list. Returns a list without the item.
-  If the item occurs more than once in the list, just the first occurrence
-  is removed.
-
-  ## Examples
-
-      iex> List.delete([1,2,3], 1)
-      [2,3]
-
-  """
-  def delete(list, item) do
-    :lists.delete(item, list)
-  end
-
-  @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]]
-  """
-  def duplicate(elem, n) do
-    :lists.duplicate(n, elem)
-  end
-
-  @doc """
-  Flattens the given `list` of nested lists. An optional
-  tail can be given that will be added at the end of
-  the flattened list.
-
-  ## Examples
-
-      iex> List.flatten([1,[[2],3]])
-      [1,2,3]
-
-      iex> List.flatten([1,[[2],3]], [4,5])
-      [1,2,3,4,5]
-
-  """
-  def flatten(list) do
-    :lists.flatten(list)
-  end
-
-  def flatten(list, tail) do
-    :lists.flatten(list, tail)
-  end
-
-  @doc """
-  Folds (reduces) the given list to 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
-
-  """
-  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 to the right with
-  a function. Requires an accumulator.
-
-  ## Examples
-
-      iex> List.foldr([1,2,3,4], 0, fn (x, acc) -> x - acc end)
-      -2
-
-  """
-  def foldr(list, acc, function) when is_list(list) and is_function(function) do
-    :lists.foldr(function, acc, list)
-  end
-
-  @doc """
-  Returns the last element in `list` or nil if the `list` is empty.
-
-  ## Examples
-
-      iex> List.last([])
-      nil
-      iex> List.last([1])
-      1
-      iex> List.last([1, 2, 3])
-      3
-
-  """
-  def last([]), do: nil
-
-  def last(list) do
-    :lists.last(list)
-  end
-
-  @doc """
-  Receives a list of tuples and returns the first tuple
-  where the item at position `position` matches with the
-  given `item`.
-
-  ## 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
-
-  """
-  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 `position` matches
-  with the given `item`.
-
-  ## 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
-
-  """
-  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 `pos` if it exists.
-
-  ## Examples
-
-      iex> List.keyreplace([a: 1, b: 2], :a, 0, { :a, 3 })
-      [a: 3, b: 2]
-
-  """
-  def keyreplace(list, key, position, new_tuple) do
-    :lists.keyreplace(key, position + 1, list, new_tuple)
-  end
-
-  @doc """
-  Receives a list of tuples and replaces the item
-  identified by `key` at position `pos`. 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]
-
-  """
-  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 `position` matches with the
-  given `item`. Returns the new tuple.
-
-  ## 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 }]
-
-  """
-  def keydelete(list, key, position) do
-    :lists.keydelete(key, position + 1, list)
-  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([1,2,3])
-      [1,2,3]
-
-  """
-  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`.
-
-  ## 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}]
-
-  """
-  def zip([]), do: []
-  def zip(list_of_lists) when is_list(list_of_lists) do
-    do_zip(list_of_lists, [])
-  end
-
-  @doc """
-  Unzips the given list of lists or tuples into separate lists and returns a
-  list of lists.
-
-  ## Examples
-
-      iex> List.unzip([{1, 2}, {3, 4}])
-      [[1, 3], [2, 4]]
-
-      iex> List.unzip([{1, :a, "apple"}, {2, :b, "banana"}, {3, :c}])
-      [[1, 2, 3], [:a, :b, :c]]
-
-  """
-  def unzip(list) when is_list(list) do
-    :lists.map tuple_to_list(&1), zip(list)
-  end
-
-  @doc """
-  Returns a list with an inserted value at specified index. Note that the index
-  is capped at the list length and that negative indicies wraps around at 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, 0, 3]
-
-  """
-  def insert_at(list, index, value) do
-    if index < 0 do
-      do_insert_at(list, length(list) + index, value)
-    else
-      do_insert_at(list, index, value)
-    end
-  end
-
-  ## Helpers
-
-  # 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([h|t], index, value) do
-    [ h | do_insert_at(t, index - 1, value) ]
-  end
-
-  # zip
-
-  defp do_zip(list, acc) do
-    converter = fn x, acc -> do_zip_each(to_list(x), acc) end
-    {mlist, heads} = :lists.mapfoldl converter, [], list
-
-    case heads do
-      nil -> :lists.reverse acc
-      _   -> do_zip mlist, [list_to_tuple(:lists.reverse(heads))|acc]
-    end
-  end
-
-  defp do_zip_each(_, nil) do
-    { nil, nil }
-  end
-
-  defp do_zip_each([h|t], acc) do
-    { t, [h|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
@@ -1,44 +0,0 @@
-defprotocol List.Chars do
-  @moduledoc %B"""
-  The List.Chars protocol is responsible for
-  converting a structure to a list (only if applicable).
-  The only function required to be implemented is
-  `to_char_list` which does the conversion.
-
-  The `to_char_list` function automatically imported
-  by Kernel invokes this protocol.
-  """
-
-  @only [BitString, List, Atom, Number, Record]
-
-  def to_char_list(thing)
-end
-
-defimpl List.Chars, for: Atom do
-  def to_char_list(atom), do: atom_to_list(atom)
-end
-
-defimpl List.Chars, for: BitString do
-  def to_char_list(bitstring), do: bitstring_to_list(bitstring)
-end
-
-defimpl List.Chars, for: List do
-  def to_char_list(list), do: list
-end
-
-defimpl List.Chars, for: Number do
-  @digits 20
-  @limit  :math.pow(10, @digits)
-
-  def to_char_list(thing) when is_integer(thing) do
-    integer_to_list(thing)
-  end
-
-  def to_char_list(thing) when thing > @limit do
-    float_to_list(thing, scientific: @digits)
-  end
-
-  def to_char_list(thing) do
-    float_to_list(thing, compact: true, decimals: @digits)
-  end
-end
@@ -1,214 +0,0 @@
-defmodule ListDict do
-  @moduledoc """
-  A Dict implementation that works on lists of two-items tuples.
-
-  For more information about the functions and their APIs, please
-  consult the `Dict` module.
-  """
-
-  @doc """
-  Returns a new `ListDict`, i.e. an empty list.
-  """
-  def new, do: []
-
-  @doc """
-  Creates a new `ListDict` from the given pairs.
-  """
-  def new(pairs) do
-    Enum.map pairs, fn({ k, v }) -> { k, v } end
-  end
-
-  @doc """
-  Creates a new `ListDict` from the given pairs
-  via the given transformation function.
-  """
-  def new(list, transform) when is_function(transform) do
-    Enum.map list, transform
-  end
-
-  @doc """
-  Returns all keys in the dict.
-  """
-  def keys(dict) do
-    lc { key, _ } inlist dict, do: key
-  end
-
-  @doc """
-  Returns all values in the dict.
-  """
-  def values(dict) do
-    lc { _, value } inlist dict, do: value
-  end
-
-  @doc """
-  Returns the dict size.
-  """
-  def size(dict) do
-    length(dict)
-  end
-
-  @doc """
-  Returns true if the dict has the given key.
-  """
-  def has_key?(dict, key) do
-    :lists.keymember(key, 1, dict)
-  end
-
-  @doc """
-  Returns the value under key from the given
-  dict or default if no key is set.
-  """
-  def get(dict, key, default // nil) do
-    case :lists.keyfind(key, 1, dict) do
-      { ^key, value } -> value
-      false -> default
-    end
-  end
-
-  @doc """
-  Returns the value under key from the given
-  dict in a tagged tuple, otherwise `:error`.
-  """
-  def fetch(dict, key) do
-    case :lists.keyfind(key, 1, dict) do
-      { ^key, value } -> { :ok, value }
-      false -> :error
-    end
-  end
-
-  @doc """
-  Returns the value under the given key
-  raises `KeyError` if the key does not exist.
-  """
-  def fetch!(dict, key) do
-    case :lists.keyfind(key, 1, dict) do
-      { ^key, value } -> value
-      false -> raise(KeyError, key: key)
-    end
-  end
-
-  @doc """
-  Returns the value under the given key
-  from the dict as well as the dict without that key.
-  """
-  def pop(dict, key, default // nil) do
-    { get(dict, key, default), delete(dict, key) }
-  end
-
-  @doc """
-  Puts the given key-value pair in the dict.
-  """
-  def put(dict, key, val) do
-    [{key, val}|delete(dict, key)]
-  end
-
-  @doc """
-  Puts the given key-value pair in the dict
-  if no entry exists yet.
-  """
-  def put_new(dict, key, val) do
-    case :lists.keyfind(key, 1, dict) do
-      { ^key, _ } -> dict
-      false -> [{key,val}|dict]
-    end
-  end
-
-  @doc """
-  Deletes the entry under the given key from the dict.
-  """
-  def delete(dict, key) do
-    lc { k, _ } = tuple inlist dict, key != k, do: tuple
-  end
-
-  @doc """
-  Merges the given Enumerable into the dict.
-  """
-  def merge(dict, enum, callback // fn(_k, _v1, v2) -> v2 end)
-
-  def merge(dict1, dict2, fun) do
-    Enum.reduce dict2, dict1, fn { k, v2 }, acc ->
-      update(acc, k, v2, fn(v1) -> fun.(k, v1, v2) end)
-    end
-  end
-
-  @doc """
-  Splits a dict into two dicts,
-  one containing entries with key in the keys list,
-  and another containing entries with key not in keys.
-  Returns a 2-tuple of the new dicts.
-  """
-  def split(dict, keys) do
-    acc = { new(), new() }
-    Enum.reduce dict, acc, fn({ k, v }, { take, drop }) ->
-      if :lists.member(k, keys) do
-        { [{k,v}|take], drop }
-      else
-        { take, [{k,v}|drop] }
-      end
-    end
-  end
-
-  @doc """
-  Returns a new dict with only the entries
-  which key is in keys
-  """
-  def take(dict, keys) do
-    lc { k, _ } = tuple inlist dict, :lists.member(k, keys), do: tuple
-  end
-
-  @doc """
-  Returns a new dict with only the entries
-  which key is not in keys
-  """
-  def drop(dict, keys) do
-    lc { k, _ } = tuple inlist dict, not :lists.member(k, keys), do: tuple
-  end
-
-  @doc """
-  Updates the key in the dict according to the given function.
-  """
-  def update([{key, value}|dict], key, fun) do
-    [{key, fun.(value)}|delete(dict, key)]
-  end
-
-  def update([{_, _} = e|dict], key, fun) do
-    [e|update(dict, key, fun)]
-  end
-
-  def update([], key, _fun) do
-    raise(KeyError, key: key)
-  end
-
-  @doc """
-  Updates the key in the dict according to the given function
-  or uses the given initial value if no entry exists.
-  """
-  def update([{key, value}|dict], key, _initial, fun) do
-    [{key, fun.(value)}|delete(dict, key)]
-  end
-
-  def update([{_, _} = e|dict], key, initial, fun) do
-    [e|update(dict, key, initial, fun)]
-  end
-
-  def update([], key, initial, _fun) do
-    [{key, initial}]
-  end
-
-  @doc """
-  Returns an empty `ListDict`.
-  """
-  def empty(_dict), do: []
-
-  @doc """
-  Check if the ListDict is equal to another ListDict.
-  """
-  def equal?(dict, other) do
-    :lists.keysort(1, dict) == :lists.keysort(1, other)
-  end
-
-  @doc """
-  Converts the dict to a list.
-  """
-  def to_list(dict), do: dict
-end
@@ -1,550 +0,0 @@
-import Kernel, except: [to_binary: 1]
-
-defmodule Macro do
-  @moduledoc """
-  This module provides conveniences for working with macros.
-  """
-
-  @doc """
-  Returns a list of binary operators. This is available
-  as a macro so it can be used in guard clauses.
-  """
-  defmacro binary_ops do
-    [
-      :===, :!==,
-      :==, :!=, :<=, :>=,
-      :&&, :||, :<>, :++, :--, :**, ://, :::, :<-, :.., :|>, :=~,
-      :<, :>,
-      :+, :-, :*, :/, :=, :|, :.,
-      :and, :or, :xor, :when, :in, :inlist, :inbits,
-      :<<<, :>>>, :|||, :&&&, :^^^, :~~~
-    ]
-  end
-
-  @doc """
-  Returns a list of unary operators. This is available
-  as a macro so it can be used in guard clauses.
-  """
-  defmacro unary_ops do
-    [:!, :@, :^, :not, :+, :-]
-  end
-
-  @doc """
-  Receives an expresion representing a possible definition
-  and extracts its arguments. It returns a tuple with the
-  function name and the arguments list or `:error` if not
-  a valid call syntax.
-
-  This is useful for macros that want to provide the same
-  arguments syntax available in def/defp/defmacro and friends.
-
-  ## Examples
-
-      extract_args(quote do: foo)        == { :foo, [] }
-      extract_args(quote do: foo())      == { :foo, [] }
-      extract_args(quote do: foo(1,2,3)) == { :foo, [1,2,3] }
-      extract_args(quote do: 1.(1,2,3))  == :error
-
-  """
-  def extract_args(expr) do
-    :elixir_clauses.extract_args(expr)
-  end
-
-  @doc """
-  Recursively escapes a value so it can be inserted
-  into a syntax tree.
-
-  ## Examples
-
-      iex> Macro.escape(:foo)
-      :foo
-
-      iex> Macro.escape({ :a, :b, :c })
-      { :{}, [], [:a, :b, :c] }
-
-  """
-  def escape(expr) do
-    :elixir_quote.escape(expr, false) |> elem(0)
-  end
-
-  @doc false
-  def escape_quoted(expr) do
-    :elixir_quote.escape(expr, true) |> elem(0)
-  end
-
-  @doc %B"""
-  Unescape the given chars. This is the unescaping behavior
-  used by default in Elixir single- and double-quoted strings.
-  Check `unescape_binary/2` for information on how to customize
-  the escaping map.
-
-  In this setup, Elixir will escape the following: `\a`, `\b`,
-  `\d`, `\e`, `\f`, `\n`, `\r`, `\s`, `\t` and `\v`. Octals are
-  also escaped according to the latin1 set they represent.
-
-  This function is commonly used on sigil implementations
-  (like `%r`, `%b` and others).
-
-  ## Examples
-
-      iex> Macro.unescape_binary("example\\n")
-      "example\n"
-
-  In the example above, we pass a string with `\n` escaped
-  and we return a version with it unescaped.
-  """
-  def unescape_binary(chars) do
-    :elixir_interpolation.unescape_chars(chars)
-  end
-
-  @doc %B"""
-  Unescape the given chars according to the map given.
-  Check `unescape_binary/1` if you want to use the same map
-  as Elixir single- and double-quoted strings.
-
-  ## Map
-
-  The map must be a function. The function receives an integer
-  representing the number of the characters it wants to unescape.
-  Here is the default mapping function implemented by Elixir:
-
-      def unescape_map(?a), do: ?\a
-      def unescape_map(?b), do: ?\b
-      def unescape_map(?d), do: ?\d
-      def unescape_map(?e), do: ?\e
-      def unescape_map(?f), do: ?\f
-      def unescape_map(?n), do: ?\n
-      def unescape_map(?r), do: ?\r
-      def unescape_map(?s), do: ?\s
-      def unescape_map(?t), do: ?\t
-      def unescape_map(?v), do: ?\v
-      def unescape_map(e),  do: e
-
-  If the `unescape_map` function returns false. The char is
-  not escaped and `\` is kept in the char list.
-
-  ## Octals
-
-  Octals will by default be escaped unless the map function
-  returns false for ?0.
-
-  ## Hex
-
-  Octals will by default be escaped unless the map function
-  returns false for ?x.
-
-  ## Examples
-
-  Using the unescape_map defined above is easy:
-
-      Macro.unescape_binary "example\\n", unescape_map(&1)
-
-  """
-  def unescape_binary(chars, map) do
-    :elixir_interpolation.unescape_chars(chars, map)
-  end
-
-  @doc """
-  Unescape the given tokens according to the default map.
-  Check `unescape_binary/1` and `unescape_binary/2` for more
-  information about unescaping.
-
-  Only tokens that are binaries are unescaped, all others are
-  ignored. This function is useful when implementing your own
-  sigils. Check the implementation of `Kernel.__b__`
-  for examples.
-  """
-  def unescape_tokens(tokens) do
-    :elixir_interpolation.unescape_tokens(tokens)
-  end
-
-  @doc """
-  Unescape the given tokens according to the given map.
-  Check `unescape_tokens/1` and `unescape_binary/2` for more information.
-  """
-  def unescape_tokens(tokens, map) do
-    :elixir_interpolation.unescape_tokens(tokens, map)
-  end
-
-  @doc """
-  Converts the given expression to a binary.
-
-  ## Examples
-
-      iex> Macro.to_binary(quote do: foo.bar(1, 2, 3))
-      "foo.bar(1, 2, 3)"
-
-  """
-  def to_binary(tree)
-
-  # Variables
-  def to_binary({ var, _, atom }) when is_atom(atom) do
-    atom_to_binary(var, :utf8)
-  end
-
-  # Aliases
-  def to_binary({ :__aliases__, _, refs }) do
-    Enum.map_join(refs, ".", call_to_binary(&1))
-  end
-
-  # Blocks
-  def to_binary({ :__block__, _, [expr] }) do
-    to_binary(expr)
-  end
-
-  def to_binary({ :__block__, _, _ } = expr) do
-    block = adjust_new_lines block_to_binary(expr), "\n  "
-    "(\n  " <> block <> "\n)"
-  end
-
-  # Bits containers
-  def to_binary({ :<<>>, _, args }) do
-    "<<" <> Enum.map_join(args, ", ", to_binary(&1)) <> ">>"
-  end
-
-  # Tuple containers
-  def to_binary({ :{}, _, args }) do
-    "{" <> Enum.map_join(args, ", ", to_binary(&1)) <> "}"
-  end
-
-  # List containers
-  def to_binary({ :[], _, args }) do
-    "[" <> Enum.map_join(args, ", ", to_binary(&1)) <> "]"
-  end
-
-  # Fn keyword
-  def to_binary({ :fn, _, [[do: { :->, _, [{_,tuple}] } = arrow]] })
-      when not is_tuple(tuple) or elem(tuple, 0) != :__block__ do
-    "fn " <> arrow_to_binary(arrow) <> " end"
-  end
-
-  def to_binary({ :fn, _, [[do: { :->, _, [_] } = block]] }) do
-    "fn " <> block_to_binary(block) <> "\nend"
-  end
-
-  def to_binary({ :fn, _, [[do: block]] }) do
-    block = adjust_new_lines block_to_binary(block), "\n  "
-    "fn\n  " <> block <> "\nend"
-  end
-
-  # Partial call
-  def to_binary({ :&, _, [num] }) do
-    "&#{num}"
-  end
-
-  # left -> right
-  def to_binary({ :->, _, _ } = arrow) do
-    "(" <> arrow_to_binary(arrow, true) <> ")"
-  end
-
-  # Binary ops
-  def to_binary({ op, _, [left, right] }) when op in binary_ops do
-    op_to_binary(left) <> " #{op} " <> op_to_binary(right)
-  end
-
-  # Unary ops
-  def to_binary({ :not, _, [arg] })  do
-    "not " <> to_binary(arg)
-  end
-
-  def to_binary({ op, _, [arg] }) when op in unary_ops do
-    atom_to_binary(op, :utf8) <> to_binary(arg)
-  end
-
-  # All other calls
-  def to_binary({ target, _, args }) when is_list(args) do
-    { list, last } = :elixir_tree_helpers.split_last(args)
-    case is_kw_blocks?(last) do
-      true  -> call_to_binary_with_args(target, list) <> kw_blocks_to_binary(last)
-      false -> call_to_binary_with_args(target, args)
-    end
-  end
-
-  # Two-item tuples
-  def to_binary({ left, right }) do
-    to_binary({ :{}, [], [left, right] })
-  end
-
-  # Lists
-  def to_binary(list) when is_list(list) do
-    to_binary({ :[], [], list })
-  end
-
-  # All other structures
-  def to_binary(other), do: inspect(other, raw: true)
-
-  # Block keywords
-  defmacrop kw_keywords, do: [:do, :catch, :rescue, :after, :else]
-
-  defp is_kw_blocks?([_|_] = kw) do
-    Enum.all?(kw, match?({x, _} when x in kw_keywords, &1))
-  end
-  defp is_kw_blocks?(_), do: false
-
-  defp module_to_binary(atom) when is_atom(atom), do: inspect(atom, raw: true)
-  defp module_to_binary(other), do: call_to_binary(other)
-
-  defp call_to_binary(atom) when is_atom(atom),  do: atom_to_binary(atom, :utf8)
-  defp call_to_binary({ :., _, [arg] }),         do: module_to_binary(arg) <> "."
-  defp call_to_binary({ :., _, [left, right] }), do: module_to_binary(left) <> "." <> call_to_binary(right)
-  defp call_to_binary(other),                    do: to_binary(other)
-
-  defp call_to_binary_with_args(target, args) do
-    args = Enum.map_join(args, ", ", to_binary(&1))
-    call_to_binary(target) <> "(" <> args <> ")"
-  end
-
-  defp kw_blocks_to_binary(kw) do
-    Enum.reduce(kw_keywords, " ", fn(x, acc) ->
-      case Keyword.has_key?(kw, x) do
-        true  -> acc <> kw_block_to_binary(x, Keyword.get(kw, x))
-        false -> acc
-      end
-    end) <> "end"
-  end
-
-  defp kw_block_to_binary(key, value) do
-    block = adjust_new_lines block_to_binary(value), "\n  "
-    atom_to_binary(key, :utf8) <> "\n  " <> block <> "\n"
-  end
-
-  defp block_to_binary({ :->, _, exprs }) do
-    Enum.map_join(exprs, "\n", fn({ left, right }) ->
-      left = comma_join_or_empty_paren(left, false)
-      left <> "->\n  " <> adjust_new_lines block_to_binary(right), "\n  "
-    end)
-  end
-
-  defp block_to_binary({ :__block__, _, exprs }) do
-    Enum.map_join(exprs, "\n", to_binary(&1))
-  end
-
-  defp block_to_binary(other), do: to_binary(other)
-
-  defp op_to_binary({ op, _, [_, _] } = expr) when op in binary_ops do
-    "(" <> to_binary(expr) <> ")"
-  end
-
-  defp op_to_binary(expr), do: to_binary(expr)
-
-  defp arrow_to_binary({ :->, _, pairs }, paren // false) do
-    Enum.map_join(pairs, "; ", fn({ left, right }) ->
-      left = comma_join_or_empty_paren(left, paren)
-      left <> "-> " <> to_binary(right)
-    end)
-  end
-
-  defp comma_join_or_empty_paren([], true),  do: "() "
-  defp comma_join_or_empty_paren([], false), do: ""
-
-  defp comma_join_or_empty_paren(left, _) do
-    Enum.map_join(left, ", ", to_binary(&1)) <> " "
-  end
-
-  defp adjust_new_lines(block, replacement) do
-    bc <<x>> inbits block do
-      << case x == ?\n do
-        true  -> replacement
-        false -> <<x>>
-      end :: binary >>
-    end
-  end
-
-  @doc """
-  Receives an expression representation and expands it. The following
-  contents are expanded:
-
-  * Macros (local or remote);
-  * Aliases are expanded (if possible) and return atoms;
-  * All pseudo-variables (__FILE__, __MODULE__, etc);
-  * Module attributes reader (@foo);
-
-  In case the expression cannot be expanded, it returns the expression itself.
-
-  Notice that `Macro.expand` is not recursive and it does not
-  expand child expressions. In this example
-
-    Macro.expand(quote(do: !some_macro), __ENV__)
-
-  `!some_macro` will expand to something like:
-
-      case some_macro do
-        false -> true
-        nil   -> true
-        _     -> false
-      end
-
-  Notice that the `!` operator is a macro that expands to a case.
-  Even though `some_macro` is also a macro, it is not expanded
-  because it is a child expression given to `!` as argument.
-
-  ## Examples
-
-  In the example below, we have a macro that generates a module
-  with a function named `name_length` that returns the length
-  of the module name. The value of this function will be calculated
-  at compilation time and not at runtime.
-
-  Consider the implementation below:
-
-      defmacro defmodule_with_length(name, do: block) do
-        length = length(atom_to_list(name))
-
-        quote do
-          defmodule unquote(name) do
-            def name_length, do: unquote(length)
-            unquote(block)
-          end
-        end
-      end
-
-  When invoked like this:
-
-      defmodule_with_length My.Module do
-        def other_function, do: ...
-      end
-
-  The compilation will fail because `My.Module` when quoted
-  is not an atom, but a syntax tree as follow:
-
-      {:__aliases__, [], [:My, :Module] }
-
-  That said, we need to expand the aliases node above to an
-  atom, so we can retrieve its length. Expanding the node is
-  not straight-forward because we also need to expand the
-  caller aliases. For example:
-
-      alias MyHelpers, as: My
-
-      defmodule_with_length My.Module do
-        def other_function, do: ...
-      end
-
-  The final module name will be `MyHelpers.Module` and not
-  `My.Module`. With `Macro.expand`, such aliases are taken
-  into consideration. Local and remote macros are also
-  expanded. We could rewrite our macro above to use this
-  function as:
-
-      defmacro defmodule_with_length(name, do: block) do
-        expanded = Macro.expand(name, __CALLER__)
-        length   = length(atom_to_list(expanded))
-
-        quote do
-          defmodule unquote(name) do
-            def name_length, do: unquote(length)
-            unquote(block)
-          end
-        end
-      end
-
-  """
-  def expand(aliases, env) do
-    expand(aliases, env, nil)
-  end
-
-  defp expand({ :__aliases__, _, _ } = original, env, cache) do
-    case :elixir_aliases.expand(original, env.aliases, env.macro_aliases) do
-      atom when is_atom(atom) -> atom
-      aliases ->
-        aliases = lc alias inlist aliases, do: expand(alias, env, cache)
-
-        case :lists.all(is_atom(&1), aliases) do
-          true  -> :elixir_aliases.concat(aliases)
-          false -> original
-        end
-    end
-  end
-
-  # Expand @ calls
-  defp expand({ :@, _, [{ name, _, args }] } = original, env, _cache) when is_atom(args) or args == [] do
-    case (module = env.module) && Module.open?(module) do
-      true  -> Module.get_attribute(module, name)
-      false -> original
-    end
-  end
-
-  # Expand pseudo-variables
-  defp expand({ :__MODULE__, _, atom }, env, _cache) when is_atom(atom), do: env.module
-  defp expand({ :__FILE__, _, atom }, env, _cache)   when is_atom(atom), do: env.file
-  defp expand({ :__DIR__, _, atom }, env, _cache)    when is_atom(atom), do: :filename.dirname(env.file)
-  defp expand({ :__ENV__, _, atom }, env, _cache)    when is_atom(atom), do: env
-
-  # Expand possible macro import invocation
-  defp expand({ atom, line, args } = original, env, cache) when is_atom(atom) do
-    args = case is_atom(args) do
-      true  -> []
-      false -> args
-    end
-
-    case not is_partial?(args) do
-      false -> original
-      true  ->
-        module = env.module
-
-        extra  = if function_exported?(module, :__info__, 1) do
-          [{ module, module.__info__(:macros) }]
-        else
-          []
-        end
-
-        expand = :elixir_dispatch.expand_import(line, { atom, length(args) }, args,
-          env.module, extra, to_erl_env(env, cache))
-        case expand do
-          { :ok, _, expanded } -> expanded
-          { :error, _ }     -> original
-        end
-    end
-  end
-
-  # Expand possible macro require invocation
-  defp expand({ { :., _, [left, right] }, line, args } = original, env, cache) when is_atom(right) do
-    receiver = expand(left, env)
-
-    case is_atom(receiver) and not is_partial?(args) do
-      false -> original
-      true  ->
-        expand = :elixir_dispatch.expand_require(line, receiver, { right, length(args) },
-          args, env.module, to_erl_env(env, cache))
-        case expand do
-          { :ok, _receiver, expanded } -> expanded
-          { :error, _ }                -> original
-        end
-    end
-  end
-
-  # Anything else is just returned
-  defp expand(other, _env, _cache), do: other
-
-  defp to_erl_env(env, nil),    do: :elixir_scope.to_erl_env(env)
-  defp to_erl_env(_env, cache), do: cache
-
-  ## Helpers
-
-  defp is_partial?(args) do
-    :lists.any(match?({ :&, _, [_] }, &1), args)
-  end
-
-  @doc """
-  Recurs the quoted expression checking if all sub terms are
-  safe (i.e. they represented data structured and don't actually
-  evaluate code) and returns `:ok` unless a given term is unsafe,
-  which is returned as `{ :unsafe, term }`.
-  """
-  def safe_term(terms) do
-    do_safe_term(terms) || :ok
-  end
-
-  defp do_safe_term({ local, _, terms }) when local in [:{}, :[], :__aliases__] do
-    do_safe_term(terms)
-  end
-
-  defp do_safe_term({ unary, _, [term] }) when unary in [:+, :-] do
-    do_safe_term(term)
-  end
-
-  defp do_safe_term({ left, right }), do: do_safe_term(left) || do_safe_term(right)
-  defp do_safe_term(terms) when is_list(terms),  do: Enum.find_value(terms, do_safe_term(&1))
-  defp do_safe_term(terms) when is_tuple(terms), do: { :unsafe, terms }
-  defp do_safe_term(_), do: nil
-end
@@ -1,81 +0,0 @@
-defmodule Macro.Env do
-  @moduledoc """
-  A record that holds compile time environment information.
-
-  The current environment can be accessed at any time as
-  `__ENV__`. Inside macros, the caller environment can be
-  accessed as `__CALLER__`. 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 seconds its arity. Returns
-    `nil` if not inside a function
-  * `aliases` -  a list of two item tuples, where the first
-    item is the aliased name and the second the actual name
-  * `context` - the context of the environment. It can be nil
-    (default context), inside a guard or inside an assign
-  * `requires` - the list of required modules
-  * `functions` - a list of functions imported from each module
-  * `macros` - a list of macros imported from each module
-  * `context_modules` - a list of modules defined in the current context
-  * `macro_aliases` - a list of aliases defined inside the current macro
-  """
-
-  @type name_arity :: { atom, non_neg_integer }
-  @type file :: binary
-  @type line :: non_neg_integer
-  @type aliases :: [{ module, module }]
-  @type context :: :match | :guard | nil
-  @type requires :: [module]
-  @type functions :: [{ module, [name_arity] }]
-  @type macros :: [{ module, [name_arity] }]
-  @type context_modules :: [module]
-
-  fields = [:module, :file, :line, :function, :aliases, :context, :requires,
-            :functions, :macros, :context_modules, :macro_aliases]
-
-  types  = quote do: [module: module, file: file, line: line,
-    function: name_arity, aliases: aliases, requires: requires,
-    functions: functions, macros: macros, context_modules: context_modules,
-    macro_aliases: aliases]
-
-  Record.deffunctions(fields, __MODULE__)
-  Record.deftypes(fields, types, __MODULE__)
-
-  @doc """
-  Returns a keyword list containing the file and line
-  information as keys.
-  """
-  def location(record) do
-    [file: file(record), line: line(record)]
-  end
-
-  @doc """
-  Returns wether the compilation environment is currently
-  inside a guard.
-  """
-  def in_guard?(record), do: context(record) == :guard
-
-  @doc """
-  Returns wether the compilation environment is currently
-  inside a match clause.
-  """
-  def in_match?(record), do: context(record) == :match
-
-  @doc """
-  Returns the environment stacktrace.
-  """
-  def stacktrace(record) do
-    cond do
-      nil?(record.module) ->
-        [{ :elixir_compiler, :__FILE__, 2, location(record) }]
-      nil?(record.function) ->
-        [{ module(record), :__MODULE__, 0, location(record) }]
-      true ->
-        { name, arity } = record.function
-        [{ module(record), name, arity, location(record) }]
-    end
-  end
-end
@@ -1,907 +0,0 @@
-defmodule Module do
-  require :ets, as: ETS
-
-  defmacrop is_env(env) do
-    quote do
-      is_tuple(unquote(env)) and size(unquote(env)) > 1 and elem(unquote(env), 0) == Macro.Env
-    end
-  end
-
-  @moduledoc %B'''
-  This module provides many functions to deal with modules during
-  compilation time. It allows a developer to dynamically attach
-  documentation, add, delete and register attributes and so forth.
-
-  After a module is compiled, using many of the functions in
-  this module will raise errors, since it is out of their purpose
-  to inspect runtime data. Most of the runtime data can be inspected
-  via the `__info__(attr)` function attached to each compiled module.
-
-  ## Module attributes
-
-  Each module can be decorated with one or more attributes. The following ones
-  are currently defined by Elixir:
-
-  * `@after_compile`
-
-      A hook that will be invoked right after the current module is compiled.
-
-      Accepts a module or a tuple `{ <module>, <function atom> }`. The function
-      must take two arguments: the module environment and its bytecode.
-      When just a module is provided, the function is assumed to be
-      `__after_compile__/2`.
-
-      **Example**
-
-          defmodule M do
-            @after_compile __MODULE__
-
-            def __after_compile__(env, _bytecode) do
-              IO.inspect env
-            end
-          end
-
-  * `@before_compile`
-
-      A hook that will be invoked before the module is compiled.
-
-      Accepts a module or a tuple `{ <module>, <function/macro atom> }`. The
-      function/macro must take one argument: the module environment. If it's a
-      macro, its returned value will be injected at the end of the module definition
-      before the compilation starts.
-
-      When just a module is provided, the function/macro is assumed to be
-      `__before_compile__/1`.
-
-      **Example**
-
-          defmodule M do
-            @before_compile __MODULE__
-
-            defmacro __before_compile__(_env) do
-              quote do
-                def hello, do: "world"
-              end
-            end
-          end
-
-  * `@behaviour`   (notice the british spelling)
-
-      Specify an OTP or user-defined behaviour.
-
-      **Example**
-
-          defmodule M do
-            @behaviour gen_event
-
-            # ...
-          end
-
-  * `@compile`
-
-      Define options for module compilation that are passed to the Erlang
-      compiler.
-
-      Accepts an atom, a tuple, or a list of atoms and tuples.
-
-      See http://www.erlang.org/doc/man/compile.html for the list of supported
-      options.
-
-      **Example**
-
-            defmodule M do
-              @compile { :inline, myfun: 1 }
-
-              def myfun(arg) do
-                to_binary(arg)
-              end
-            end
-
-  * `@doc`
-
-      Provide documentation for the function or macro that follows the
-      attribute.
-
-      Accepts a string (often a heredoc) or `false` where `@doc false` will
-      make the function/macro invisible to the documentation extraction tools
-      like ExDoc.
-
-      Can be invoked more than once.
-
-      **Example**
-
-            defmodule M do
-              @doc "Hello world"
-              def hello do
-                "world"
-              end
-
-              @doc """
-              Sum.
-              """
-              def sum(a, b) do
-                a + b
-              end
-            end
-
-  * `@file`
-
-      Change the filename used in stacktraces for the function or macro that
-      follows the attribute.
-
-      Accepts a string. Can be used more than once.
-
-      **Example**
-
-            defmodule M do
-              @doc "Hello world"
-              @file "hello.ex"
-              def hello do
-                "world"
-              end
-            end
-
-  * `@moduledoc`
-
-      Provide documentation for the current module.
-
-      Accepts a string (which is often a heredoc) or `false` where
-      `@moduledoc false` will make the module invisible to the
-      documentation extraction tools like ExDoc.
-
-      **Example**
-
-            defmodule M do
-              @moduledoc """
-              A very useful module
-              """
-            end
-
-
-  * `@on_definition`
-
-      A hook that will be invoked after each function or macro in the current
-      module is defined. This makes it easy to annotate and customize
-      functions.
-
-      Accepts a module or a tuple `{ <module>, <function atom> }`. The function
-      must take 6 arguments:
-
-        - the module environment
-        - kind: `:def`, `:defp`, `:defmacro`, or `:defmacrop`
-        - function/macro name
-        - list of quoted arguments
-        - list of quoted guards
-        - quoted function body
-
-      If the function/macro being defined has multiple clauses, the hook will
-      be called for each clause.
-
-      When just a module is provided, the function is assumed to be
-      `__on_definition__/6`.
-
-      Note that you can't provide the current module to `@on_definition`
-      because the hook function will not be defined in time.
-
-      **Example**
-
-            defmodule H do
-              def on_def(_env, kind, name, args, guards, body) do
-                IO.puts "Defining #{kind} named #{name} with args:"
-                IO.inspect args
-                IO.puts "and guards"
-                IO.inspect guards
-                IO.puts "and body"
-                IO.puts Macro.to_binary(body)
-              end
-            end
-
-            defmodule M do
-              @on_definition { H, :on_def }
-
-              def hello(arg) when is_binary(arg) or is_list(arg) do
-                "Hello" <> to_binary(arg)
-              end
-
-              def hello(_) do
-                :ok
-              end
-            end
-
-  * `@on_load`
-
-      A hook that will be invoked whenever the module is loaded.
-
-      Accepts a function atom of a function in the current module. The function
-      must have arity 0 (no arguments) and has to return `:ok`, otherwise the
-      loading of the module will be aborted.
-
-      **Example**
-
-            defmodule M do
-              @on_load :load_check
-
-              def load_check do
-                if some_condition() do
-                  :ok
-                else
-                  nil
-                end
-              end
-
-              def some_condition do
-                false
-              end
-            end
-
-  * `@vsn`
-
-      Specify the module version. Accepts any valid Elixir value.
-
-      **Example**
-
-            defmodule M do
-              @vsn "1.0"
-            end
-
-  The following attributes are part of typespecs and are also reserved by
-  Elixir (see `Kernel.Typespec` for more information about typespecs):
-
-  * `@type`        - defines a type to be used in `@spec`
-  * `@typep`       - defines a private type to be used in `@spec`
-  * `@opaque`      - defines an opaque type to be used in `@spec`
-  * `@spec`        - provides a specification for a function
-  * `@callback`    - provides a specification for the behavior callback
-
-  In addition to the built-in attributes outlined above, custom attributes may
-  also be added. A custom attribute is any valid identifier prefixed with an
-  `@` and followed by a valid Elixir value:
-
-        defmodule M do
-          @custom_attr [some: "stuff"]
-        end
-
-  For more advanced options available when defining custom attributes, see
-  `register_attribute/3`.
-
-  ## Runtime information about a module
-
-  It is possible to query a module at runtime to find out which functions and
-  macros it defines, extract its docstrings, etc. See `__info__/1`.
-
-  '''
-
-  @doc """
-  Provides runtime information about functions and macros defined by the
-  module, enables docstring extraction, etc.
-
-  Each module gets an `__info__/1` function when it's compiled. The function
-  takes one of the following atoms:
-
-  * `:functions`  - keyword list of public functions along with their arities
-
-  * `:macros`     - keyword list of public macros along with their arities
-
-  * `: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
-
-  * `:module`     - module name (`Module == Module.__info__(:module)`)
-
-  In addition to the above, you may also pass to `__info__/1` any atom supported
-  by Erlang's `module_info` function which also gets defined for each compiled
-  module. See http://erlang.org/doc/reference_manual/modules.html#id74571 for
-  more information.
-  """
-  def __info__(kind)
-
-  @doc """
-  Check if a module is open, i.e. it is currently being defined
-  and its attributes and functions can be modified.
-  """
-  def open?(module) do
-    table = data_table_for(module)
-    table == ETS.info(table, :name)
-  end
-
-  @doc """
-  Evaluates the quoted contents in the given module's context.
-
-  A list of environment options can also be given as argument.
-  See `Code.eval_string` for more information.
-
-  Raises an error if the module was already compiled.
-
-  ## Examples
-
-      defmodule Foo do
-        contents = quote do: (def sum(a, b), do: a + b)
-        Module.eval_quoted __MODULE__, contents
-      end
-
-      Foo.sum(1, 2) #=> 3
-
-  For convenience, you can my pass `__ENV__` as argument and
-  all options will be automatically extracted from the environment:
-
-      defmodule Foo do
-        contents = quote do: (def sum(a, b), do: a + b)
-        Module.eval_quoted __MODULE__, contents, [], __ENV__
-      end
-
-      Foo.sum(1, 2) #=> 3
-
-  """
-  def eval_quoted(module, quoted, binding // [], opts // [])
-
-  def eval_quoted(env, quoted, binding, opts) when is_env(env) do
-    eval_quoted(env.module, quoted, binding, Keyword.merge(env.to_keywords, opts))
-  end
-
-  def eval_quoted(module, quoted, binding, env) when is_env(env) do
-    eval_quoted(module, quoted, binding, env.to_keywords)
-  end
-
-  def eval_quoted(module, quoted, binding, opts) do
-    assert_not_compiled!(:eval_quoted, module)
-    :elixir_module.eval_quoted(module, quoted, binding, opts)
-  end
-
-  @doc """
-  Creates a module with the given name and given by
-  the given quoted expressions. The line where the module
-  is defined and its file can be given as options.
-
-  ## Examples
-
-      contents =
-        quote do
-          def world, do: true
-        end
-
-      Module.create(Hello, contents, __ENV__.location)
-
-      Hello.world #=> true
-
-  ## Differences with `defmodule`
-
-  `Module.create` works similarly to `defmodule` and
-  return the same results. While one could also use
-  `defmodule` to define modules dynamically, this
-  function is preferred when the module body is given
-  by a quoted expression.
-
-  Another important distinction is that `Module.create`
-  allows you to control the environment variables used
-  when defining the module, while `defmodule` automatically
-  shares the same environment.
-  """
-  def create(module, quoted, opts // [])
-
-  def create(module, quoted, env) when is_env(env) do
-    create(module, quoted, env.to_keywords)
-  end
-
-  def create(module, quoted, opts) when is_atom(module) do
-    line = Keyword.get(opts, :line, 1)
-    :elixir_module.compile(line, module, quoted, [], :elixir.scope_for_eval(opts))
-  end
-
-  @doc """
-  Concatenates the list of aliases and returns a new alias.
-  It handles char lists, binaries and atoms.
-
-  ## Examples
-
-      iex> Module.concat([Foo, Bar])
-      Foo.Bar
-      iex> Module.concat([Foo, "Bar"])
-      Foo.Bar
-      iex> Module.concat([Foo, 'Bar'])
-      Foo.Bar
-
-  """
-  def concat(list) when is_list(list) do
-    :elixir_aliases.concat(list)
-  end
-
-  @doc """
-  Concatenates the two given aliases and returns a new alias.
-  It handles char lists, binaries and atoms.
-
-  ## Examples
-
-      iex> Module.concat(Foo, Bar)
-      Foo.Bar
-      iex> Module.concat(Foo, "Bar")
-      Foo.Bar
-      iex> Module.concat(Foo, 'Bar')
-      Foo.Bar
-
-  """
-  def concat(left, right) do
-    :elixir_aliases.concat([left, right])
-  end
-
-  @doc """
-  Concatenates the list aliases and returns a new alias only
-  if the alias was already referenced. If the alias was not
-  referenced yet, fails with ArgumentError.
-  It handles char lists, binaries and atoms.
-
-  ## Examples
-
-      iex> Module.safe_concat([Unknown, Module])
-      ** (ArgumentError) argument error
-
-      iex> Module.safe_concat([List, Chars])
-      List.Chars
-
-  """
-  def safe_concat(list) when is_list(list) do
-    :elixir_aliases.safe_concat(list)
-  end
-
-  @doc """
-  Concatenates the two aliases and returns a new alias only
-  if the alias was already referenced. If the alias was not
-  referenced yet, fails with ArgumentError.
-  It handles char lists, binaries and atoms.
-
-  ## Examples
-
-      iex> Module.safe_concat(Unknown, Module)
-      ** (ArgumentError) argument error
-
-      iex> Module.safe_concat(List, Chars)
-      List.Chars
-
-  """
-  def safe_concat(left, right) do
-    :elixir_aliases.safe_concat([left, right])
-  end
-
-  @doc """
-  Attaches documentation to a given function. It expects
-  the module the function belongs to, the line (a non negative
-  integer), the kind (def or defmacro), a tuple representing
-  the function and its arity and the documentation, which should
-  be either a binary or a boolean.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.add_doc(__MODULE__, __ENV__.line + 1, :def, { :version, 0 }, [], "Manually added docs")
-        def version, do: 1
-      end
-
-  """
-  def add_doc(_module, _line, kind, _tuple, _signature, doc) when kind in [:defp, :defmacrop] do
-    if doc, do: { :error, :private_doc }, else: :ok
-  end
-
-  def add_doc(module, line, kind, tuple, signature, doc) when
-      kind in [:def, :defmacro] and (is_binary(doc) or is_boolean(doc) or doc == nil) do
-    assert_not_compiled!(:add_doc, module)
-    table = docs_table_for(module)
-
-    { signature, _ } = Enum.map_reduce signature, 1, fn(x, acc) ->
-      { simplify_signature(x, line, acc), acc + 1 }
-    end
-
-    case ETS.lookup(table, tuple) do
-      [] ->
-        ETS.insert(table, { tuple, line, kind, signature, doc })
-        :ok
-      [{ tuple, line, _old_kind, old_sign, old_doc }] ->
-        ETS.insert(table, {
-          tuple,
-          line,
-          kind,
-          merge_signatures(old_sign, signature, 1),
-          if(nil?(doc), do: old_doc, else: doc)
-        })
-        :ok
-    end
-  end
-
-  # Simplify signatures to be stored in docs
-
-  defp simplify_signature({ ://, defline, [left, right ] }, line, i) do
-    { ://, defline, [simplify_signature(left, line, i), right] }
-  end
-
-  defp simplify_signature({ var, line, atom }, _, _i) when is_atom(atom) do
-    case atom_to_list(var) do
-      [?_|_]    -> { var, line, :guess }
-      _         -> { var, line, nil }
-    end
-  end
-
-  defp simplify_signature({ :=, _, [_, right] }, line, i) do
-    simplify_signature(right, line, i)
-  end
-
-  defp simplify_signature(other, line, i) when is_integer(other), do: { :"int#{i}", line, :guess }
-  defp simplify_signature(other, line, i) when is_boolean(other), do: { :"bool#{i}", line, :guess }
-  defp simplify_signature(other, line, i) when is_atom(other),    do: { :"atom#{i}", line, :guess }
-  defp simplify_signature(other, line, i) when is_list(other),    do: { :"list#{i}", line, :guess }
-  defp simplify_signature(other, line, i) when is_float(other),   do: { :"float#{i}", line, :guess }
-  defp simplify_signature(other, line, i) when is_binary(other),  do: { :"binary#{i}", line, :guess }
-  defp simplify_signature(_, line, i), do: { :"arg#{i}", line, :guess }
-
-  # Merge
-
-  defp merge_signatures([h1|t1], [h2|t2], i) do
-    [merge_signature(h1, h2, i)|merge_signatures(t1, t2, i + 1)]
-  end
-
-  defp merge_signatures([], [], _) do
-    []
-  end
-
-  defp merge_signature({ ://, line, [left, right] }, newer, i) do
-    { ://, line, [merge_signature(left, newer, i), right] }
-  end
-
-  defp merge_signature(older, { ://, _, [left, _] }, i) do
-    merge_signature(older, left, i)
-  end
-
-  # The older signature, when given, always have higher precedence
-  defp merge_signature({ _, _, nil } = older, _newer, _),        do: older
-  defp merge_signature(_older, { _, _, nil } = newer, _),        do: newer
-
-  # Both are a guess, so check if they are the same guess
-  defp merge_signature({ var, _, _ } = older, { var, _, _ }, _), do: older
-
-  # Otherwise, returns a generic guess
-  defp merge_signature({ _, line, _ }, _newer, i), do: { :"arg#{i}", line, :guess }
-
-  @doc """
-  Checks if the module defines the given function or macro.
-  Use `defines?/3` to assert for an specific type.
-
-  ## Examples
-
-      defmodule Example do
-        Module.defines? __MODULE__, { :version, 0 } #=> false
-        def version, do: 1
-        Module.defines? __MODULE__, { :version, 0 } #=> true
-      end
-
-  """
-  def defines?(module, tuple) when is_tuple(tuple) do
-    assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
-    ETS.lookup(table, tuple) != []
-  end
-
-  @doc """
-  Checks if the module defines a function or macro with the
-  given `kind`. `kind` can be either `:def`, `:defp`,
-  `:defmacro` or `:defmacrop`.
-
-  ## Examples
-
-      defmodule Example do
-        Module.defines? __MODULE__, { :version, 0 }, :defp #=> false
-        def version, do: 1
-        Module.defines? __MODULE__, { :version, 0 }, :defp #=> false
-      end
-
-  """
-  def defines?(module, tuple, kind) do
-    assert_not_compiled!(:defines?, module)
-    table = function_table_for(module)
-    case ETS.lookup(table, tuple) do
-      [{ _, ^kind, _, _, _, _, _ }] -> true
-      _ -> false
-    end
-  end
-
-  @doc """
-  Return all functions defined in the given module.
-
-  ## Examples
-
-      defmodule Example do
-        def version, do: 1
-        Module.definitions_in __MODULE__ #=> [{:version,1}]
-      end
-
-  """
-  def definitions_in(module) do
-    assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    lc { tuple, _, _, _, _, _, _ } inlist ETS.tab2list(table), do: tuple
-  end
-
-  @doc """
-  Returns all functions defined in te given module according
-  to its kind.
-
-  ## Examples
-
-      defmodule Example do
-        def version, do: 1
-        Module.definitions_in __MODULE__, :def  #=> [{:version,1}]
-        Module.definitions_in __MODULE__, :defp #=> []
-      end
-
-  """
-  def definitions_in(module, kind) do
-    assert_not_compiled!(:definitions_in, module)
-    table = function_table_for(module)
-    lc { tuple, stored_kind, _, _, _, _, _ } inlist ETS.tab2list(table), stored_kind == kind, do: tuple
-  end
-
-  @doc """
-  Makes the given functions in the given module overridable.
-  An overridable function is lazily defined, allowing a
-  developer to customize it. See `Kernel.defoverridable` for
-  more information and documentation.
-  """
-  def make_overridable(module, tuples) do
-    assert_not_compiled!(:make_overridable, module)
-
-    lc tuple inlist tuples do
-      case :elixir_def.lookup_definition(module, tuple) do
-        false ->
-          { name, arity } = tuple
-          raise "Cannot make function #{name}/#{arity} overridable because it was not defined"
-        clause ->
-          :elixir_def.delete_definition(module, tuple)
-          neighbours = Module.DispatchTracker.yank(module, tuple)
-
-          old    = get_attribute(module, :__overridable)
-          merged = :orddict.update(tuple, fn({ count, _, _, _ }) ->
-            { count + 1, clause, neighbours, false }
-          end, { 1, clause, neighbours, false }, old)
-
-          put_attribute(module, :__overridable, merged)
-      end
-    end
-  end
-
-  @doc """
-  Returns true if the given tuple in module is marked as overridable.
-  """
-  def overridable?(module, tuple) do
-    !! List.keyfind(get_attribute(module, :__overridable), tuple, 0)
-  end
-
-  @doc """
-  Puts an Erlang attribute to the given module with the given
-  key and value. The semantics of putting the attribute depends
-  if the attribute was registered or not via `register_attribute/2`.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
-      end
-
-  """
-  def put_attribute(module, key, value) when is_atom(key) do
-    assert_not_compiled!(:put_attribute, module)
-    table = data_table_for(module)
-    value = normalize_attribute(key, value)
-    acc   = ETS.lookup_element(table, :__acc_attributes, 2)
-
-    new =
-      if :lists.member(key, acc) do
-        case ETS.lookup(table, key) do
-          [{^key,old}] -> [value|old]
-          [] -> [value]
-        end
-      else
-        value
-      end
-
-    ETS.insert(table, { key, new })
-  end
-
-  @doc """
-  Gets the given attribute from a module. If the attribute
-  was marked as accumulate with `Module.register_attribute`,
-  a list is always returned.
-
-  ## Examples
-
-      defmodule Foo do
-        Module.put_attribute __MODULE__, :value, 1
-        Module.get_attribute __MODULE__, :value #=> 1
-
-        Module.register_attribute __MODULE__, :value, accumulate: true
-        Module.put_attribute __MODULE__, :value, 1
-        Module.get_attribute __MODULE__, :value #=> [1]
-      end
-
-  """
-  def get_attribute(module, key) when is_atom(key) do
-    assert_not_compiled!(:get_attribute, module)
-    table = data_table_for(module)
-
-    case ETS.lookup(table, key) do
-      [{^key,old}] -> old
-      [] ->
-        acc = ETS.lookup_element(table, :__acc_attributes, 2)
-        if :lists.member(key, acc), do: [], else: nil
-    end
-  end
-
-  @doc """
-  Deletes all attributes that matches the given key.
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.put_attribute __MODULE__, :custom_threshold_for_lib, 10
-        Module.delete_attribute __MODULE__, :custom_threshold_for_lib
-      end
-
-  """
-  def delete_attribute(module, key) when is_atom(key) do
-    assert_not_compiled!(:delete_attribute, module)
-    table = data_table_for(module)
-    ETS.delete(table, key)
-  end
-
-  @doc """
-  Registers an attribute. By registering an attribute, a developer
-  is able to customize how Elixir will store and accumulate the
-  attribute values.
-
-  ## Options
-
-  When registering an attribute, two options can be given:
-
-  * `:accumulate` - Several calls to the same attribute will
-    accumulate instead of override the previous one. New attributes
-    are always added to the top of the accumulated list.
-
-  * `:persist` - The attribute will be persisted in the Erlang
-    Abstract Format. Useful when interfacing with Erlang libraries.
-
-  By default, both options are true. Which means that registering
-  an attribute without passing any options will revert the attribute
-  behavior to exactly the same expected in :
-
-  ## Examples
-
-      defmodule MyModule do
-        Module.register_attribute __MODULE__,
-          :custom_threshold_for_lib,
-          accumulate: true, persist: false
-
-        @custom_threshold_for_lib 10
-        @custom_threshold_for_lib 20
-        @custom_threshold_for_lib #=> [20, 10]
-      end
-
-  """
-  def register_attribute(module, new, opts // []) do
-    assert_not_compiled!(:register_attribute, module)
-    table = data_table_for(module)
-
-    if Keyword.get(opts, :persist, true) do
-      old = ETS.lookup_element(table, :__persisted_attributes, 2)
-      ETS.insert(table, { :__persisted_attributes,  [new|old] })
-    end
-
-    if Keyword.get(opts, :accumulate, true) do
-      old = ETS.lookup_element(table, :__acc_attributes, 2)
-      ETS.insert(table, { :__acc_attributes,  [new|old] })
-    end
-  end
-
-  @doc """
-  Split the given module name into binary parts.
-
-  ## Examples
-
-      Module.split Very.Long.Module.Name.And.Even.Longer
-      #=> ["Very", "Long", "Module", "Name", "And", "Even", "Longer"]
-
-  """
-  def split(module) do
-    tl(String.split(Binary.Chars.to_binary(module), "."))
-  end
-
-  @doc """
-  Convert a module name to binary without the Elixir prefix.
-  """
-  def to_binary(Elixir), do: "Elixir"
-
-  def to_binary(module) do
-    "Elixir." <> rest = Binary.Chars.to_binary(module)
-    rest
-  end
-
-  @doc false
-  # Used internally to compile documentation. This function
-  # is private and must be used only internally.
-  def compile_doc(env, kind, name, args, _guards, _body) do
-    module = env.module
-    line   = env.line
-    arity  = length(args)
-    pair   = { name, arity }
-    doc    = get_attribute(module, :doc)
-
-    case add_doc(module, line, kind, pair, args, doc) do
-      :ok ->
-        :ok
-      { :error, :private_doc } ->
-        IO.puts "#{env.file}:#{line} function #{name}/#{arity} is private, @doc's are always discarded for private functions"
-    end
-
-    delete_attribute(module, :doc)
-  end
-
-  @doc false
-  # Used internally to compile types. This function
-  # is private and must be used only internally.
-  def compile_typespec(module, key, value) when is_atom(key) do
-    assert_not_compiled!(:put_attribute, module)
-    table = data_table_for(module)
-
-    new =
-      case ETS.lookup(table, key) do
-        [{^key,old}] -> [value|old]
-        [] -> [value]
-      end
-
-    ETS.insert(table, { key, new })
-  end
-
-  ## Helpers
-
-  defp normalize_attribute(:on_load, atom) when is_atom(atom) do
-    { atom, 0 }
-  end
-
-  defp normalize_attribute(kind, atom) when kind in [:behavior, :behaviour] and is_atom(atom) do
-    Code.ensure_compiled(atom)
-    atom
-  end
-
-  defp normalize_attribute(:file, env) when is_env(env),                    do: { binary_to_list(env.file), env.line }
-  defp normalize_attribute(:file, { binary, line }) when is_binary(binary), do: { binary_to_list(binary), line }
-  defp normalize_attribute(:file, other) when not is_tuple(other),          do: normalize_attribute(:file, { other, 1 })
-
-  defp normalize_attribute(key, atom) when is_atom(atom) and
-      key in [:before_compile, :after_compile, :on_definition] do
-    { atom, :"__#{key}__" }
-  end
-
-  defp normalize_attribute(key, _value) when key in [:type, :typep, :export_type, :opaque, :callback] do
-    raise ArgumentError, message: "Attributes type, typep, export_type, opaque and callback " <>
-      "must be set via Kernel.Typespec"
-  end
-
-  defp normalize_attribute(_key, value) do
-    value
-  end
-
-  defp data_table_for(module) do
-    module
-  end
-
-  defp function_table_for(module) do
-    :elixir_def.table(module)
-  end
-
-  defp docs_table_for(module) do
-    :elixir_module.docs_table(module)
-  end
-
-  defp assert_not_compiled!(fun, module) do
-    open?(module) ||
-      raise ArgumentError,
-        message: "could not call #{fun} on module #{inspect module} because it was already compiled"
-  end
-end
@@ -1,436 +0,0 @@
-# This is a module Elixir 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 three main
-# vertices:
-#
-# * `:local` - points to local functions
-# * `:import` - points to imported modules
-# * `:warn` - points to imported modules that should be warned
-# * `:remote` - points to remote modules
-#
-# Besides those, we have can the following vertices:
-#
-# * `Module` - a module that was invoked via an import or remotely
-# * `{ name, arity }` - a local function/arity pair
-# * `{ :import, name, arity }` - an invoked function/arity import
-# * `{ :remote, name, arity }` - an remotely invoked function/arity
-#
-# Each of those vertices can associate to other vertices
-# as described below:
-#
-# * `Module`
-#   * in neighbours: `:import`, `:remote`, `:warn`,
-#     `{ :import, name, arity }` and `{ :remote, name arity }`
-#   * out neighbours: `:warn`
-#
-# * `{ name, arity }`
-#   * in neighbours: `:local`, `{ name, arity }`
-#   * out neighbours: `{ :import, name, arity }` and `{ :remote, name arity }`
-#
-# * `{ :import, name, arity }`
-#   * in neighbours: `{ name, arity }`
-#   * out neighbours: `Module`
-#
-# * `{ :remote, 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.Behaviour` conveniences.
-defmodule Module.DispatchTracker do
-  @moduledoc false
-
-  @timeout  30_000
-  @behavior :gen_server
-
-  @type ref :: pid | module
-  @type name :: atom
-  @type name_arity :: { name, arity }
-
-  @type local :: { name, arity }
-  @type import :: { :import, name, arity }
-  @type remote :: { :remote, name, arity }
-
-  # Public API
-
-  @doc """
-  Receives a dispatch or a module and returns all dispatches
-  that calls it.
-
-  In case the argument is a module, the response will be
-  made by import and remote dispatches.
-
-  In case the argument is another dispatch, the response
-  will be made by local dispatches.
-
-  This function is not recursive, so if A dispatches to
-  B which dispatches to C, A does not appear in the result,
-  only B.
-  """
-  @spec dispatches_to(ref, module) :: [import | remote]
-  @spec dispatches_to(ref, local | import | remote) :: [local]
-  def dispatches_to(ref, dispatch) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.in_neighbours(d, dispatch) |> only_tuples
-  end
-
-  @doc """
-  Receives a local and returns all dispatches from that local.
-
-  This function is not recursive, so if A dispatches to
-  B which dispatches to C, C does not appear in the result,
-  only B.
-  """
-  @spec dispatches_from(ref, local) :: [local | import | remote]
-  def dispatches_from(ref, { name, arity }) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, { name, arity }) |> only_tuples
-  end
-
-  @doc """
-  Returns all the modules which were imported.
-  All external dependencies to a module is the sum
-  of imports and remotes.
-  """
-  @spec imports(ref) :: [module]
-  def imports(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, :import)
-  end
-
-  @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 the modules which were remotely dispatched
-  to. All external dependencies to a module is the sum
-  of imports and remotes.
-  """
-  @spec remotes(ref) :: [module]
-  def remotes(ref) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, :remote)
-  end
-
-  @doc """
-  Returns all modules that had the given `{ name, arity }`
-  invoked remotely.
-  """
-  @spec remotes_with_dispatch(ref, name_arity) :: [module]
-  def remotes_with_dispatch(ref, { name, arity }) do
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    :digraph.out_neighbours(d, { :remote, 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
-    d = :gen_server.call(to_pid(ref), :digraph, @timeout)
-    reduce_reachable(d, :local, [])
-  end
-
-  defp reduce_reachable(d, vertex, vertices) do
-    neighbours = :digraph.out_neighbours(d, vertex)
-    neighbours = (lc { _, _ } = t inlist neighbours, do: t) |> :ordsets.from_list
-    remaining  = :ordsets.subtract(neighbours, vertices)
-    vertices   = :ordsets.union(neighbours, vertices)
-    :lists.foldl(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: Module.get_attribute(mod, :__dispatch_tracker)
-
-  defp only_tuples(list) do
-    lc x inlist list, is_tuple(x), do: x
-  end
-
-  # Internal API
-
-  # Starts the tracker and returns its pid.
-  @doc false
-  def start_link do
-    { :ok, pid } = :gen_server.start_link(__MODULE__, [], [])
-    pid
-  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 a remote dispatch to the given target.
-  @doc false
-  def add_remote(pid, function, module, target) when is_atom(module) and is_tuple(target) do
-    :gen_server.cast(pid, { :add_remote, function, module, target })
-  end
-
-  # Adds a import dispatch to the given target.
-  @doc false
-  def add_import(pid, function, module, target) when is_atom(module) and is_tuple(target) do
-    :gen_server.cast(pid, { :add_import, function, module, target })
-  end
-
-  # Associates a module with a warn. This adds the given
-  # module and associates it with the `:import` vertex
-  # permanently, even if warn is false.
-  @doc false
-  def add_warnable(pid, module, warn, line) when is_atom(module) and is_boolean(warn) do
-    :gen_server.cast(pid, { :add_warnable, module, warn, line })
-  end
-
-  # Collect all unused imports where warn has been set to true.
-  def collect_unused_imports(pid) do
-    d = :gen_server.call(pid, :digraph, @timeout)
-    warnable = :digraph.out_neighbours(d, :warn)
-
-    lc mod inlist warnable, not has_imports?(d, mod), line = get_warn_line(d, mod) do
-      { mod, line }
-    end
-  end
-
-  defp get_warn_line(d, mod) do
-    [edge] = :digraph.out_edges(d, mod)
-    { ^edge, ^mod, :warn, line } = :digraph.edge(d, edge)
-    line
-  end
-
-  defp has_imports?(d, mod) do
-    Enum.any?(:digraph.in_neighbours(d, mod), match?({ :import, _, _ }, &1))
-  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
-
-  def reattach(pid, kind, tuple, neighbours) do
-    pid = to_pid(pid)
-    add_definition(pid, kind, tuple)
-    :gen_server.cast(pid, { :reattach, 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)
-
-    lc { name, arity } inlist all_defined,
-       n = :digraph.out_neighbours(d, { :import, name, arity }),
-       n != [] do
-      { n, name, arity }
-    end
-  end
-
-  # Collect all unused definitions based on the private
-  # given also accounting the expected amount of default
-  # clauses a private function have.
-  @doc false
-  def collect_unused_locals(pid, private) do
-    reachable = reachable(pid)
-    :lists.foldl(collect_unused_locals(&1, &2, reachable), [], private)
-  end
-
-  defp collect_unused_locals({ tuple, kind, 0 }, acc, reachable) do
-    if :lists.member(tuple, reachable) do
-      acc
-    else
-      [{ :unused_def, tuple, kind }|acc]
-    end
-  end
-
-  defp collect_unused_locals({ tuple, kind, default }, acc, reachable) when default > 0 do
-    { name, arity } = tuple
-    min = arity - default
-    max = arity
-
-    invoked = lc { n, a } inlist reachable, n == name, a in min..max, do: a
-
-    if invoked == [] do
-      [{ :unused_def, tuple, kind }|acc]
-    else
-      case :lists.min(invoked) - min do
-        0 -> acc
-        ^default -> [{ :unused_args, tuple }|acc]
-        unused_args -> [{ :unused_args, tuple, unused_args }|acc]
-      end
-    end
-  end
-
-  # 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)
-    :digraph.add_vertex(d, :import)
-    :digraph.add_vertex(d, :remote)
-    :digraph.add_vertex(d, :warn)
-    { :ok, d }
-  end
-
-  def handle_call({ :yank, local }, _from, d) do
-    in_vertices  = :digraph.in_neighbours(d, local)
-    out_vertices = :digraph.out_neighbours(d, local)
-    :digraph.del_vertex(d, local)
-    { :reply, { in_vertices, out_vertices }, d }
-  end
-
-  def handle_call(:digraph, _from, d) do
-    { :reply, d, d }
-  end
-
-  def handle_call(_request, _from, d) do
-    { :noreply, d }
-  end
-
-  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_remote, function, module, { name, arity } }, d) do
-    handle_import_or_remote(d, :remote, function, module, name, arity)
-    { :noreply, d }
-  end
-
-  def handle_cast({ :add_import, function, module, { name, arity } }, d) do
-    handle_import_or_remote(d, :import, function, module, name, arity)
-    { :noreply, d }
-  end
-
-  def handle_cast({ :add_warnable, module, warn, line }, d) do
-    :digraph.add_vertex(d, module)
-    replace_edge!(d, :import, module)
-
-    if warn do
-      :digraph.add_edge(d, :warn, module, line)
-      :digraph.add_edge(d, module, :warn, line)
-    else
-      :digraph.del_path(d, :warn, module)
-    end
-    { :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
-    lc i inlist :lists.seq(arity - defaults, arity - 1) do
-      handle_add_definition(d, kind, { name, i })
-      handle_add_local(d, { name, i }, { name, i + 1 })
-    end
-    { :noreply, d }
-  end
-
-  def handle_cast({ :reattach, tuple, { in_neigh, out_neigh } }, d) do
-    lc from inlist in_neigh, do: replace_edge(d, from, tuple)
-    lc to inlist out_neigh,  do: replace_edge(d, tuple, to)
-    { :noreply, d }
-  end
-
-  def handle_cast(:stop, d) do
-    { :stop, :normal, d }
-  end
-
-  def handle_cast(_msg, d) do
-    { :noreply, d }
-  end
-
-  def terminate(_reason, _d) do
-    :ok
-  end
-
-  def code_change(_old, d, _extra) do
-    { :ok, d }
-  end
-
-  defp handle_import_or_remote(d, kind, function, module, name, arity) do
-    :digraph.add_vertex(d, module)
-    replace_edge!(d, kind, module)
-
-    tuple = { kind, name, arity }
-    :digraph.add_vertex(d, tuple)
-    replace_edge!(d, tuple, module)
-
-    if function != nil do
-      replace_edge!(d, function, tuple)
-    end
-  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
-  end
-
-  defp replace_edge(d, from, to) do
-    unless :lists.member(to, :digraph.out_neighbours(d, from)) do
-      :digraph.add_edge(d, from, to)
-    end
-  end
-end
@@ -1,186 +0,0 @@
-defmodule Node do
-  @moduledoc """
-  Functions related to Erlang nodes.
-  """
-
-  @type t :: atom
-
-  @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. Otherwise, it returns false.
-  """
-  @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.
-
-  See http://www.erlang.org/doc/man/erlang.html#nodes-1 for more info.
-  """
-  @typep list_arg :: :visible | :hidden | :connected | :this | :known
-  @spec list(list_arg | [list_arg]) :: [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.
-
-  See http://www.erlang.org/doc/man/erlang.html#monitor_node-2 for more info.
-  """
-  @spec monitor(t, boolean) :: true
-  def monitor(node, flag) do
-    :erlang.monitor_node(node, flag)
-  end
-
-  @doc """
-  Behaves as monitor_node/2 except that it allows an extra
-  option to be given, namely :allow_passive_connect.
-
-  See http://www.erlang.org/doc/man/erlang.html#monitor_node-3 for more info.
-  """
-  @spec monitor(t, boolean, [:allow_passive_connect]) :: true
-  def monitor(node, flag, options) do
-    :erlang.monitor_node(node, flag, options)
-  end
-
-  @doc """
-  Forces the disconnection of a node. This will appear to the `node` as if
-  the local node has crashed. This BIF 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.
-
-  See http://www.erlang.org/doc/man/erlang.html#disconnect_node-1 for more info.
-  """
-  @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.
-
-  See http://erlang.org/doc/man/net_kernel.html#connect_node-1 for more info.
-  """
-  @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.
-
-  Check http://www.erlang.org/doc/man/erlang.html#spawn-2 for
-  the list of available options.
-  """
-  @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.
-
-  Check http://www.erlang.org/doc/man/erlang.html#spawn_opt-3 for
-  the list of available options.
-  """
-  @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 exists,
-  a useless pid is returned.
-
-  Check http://www.erlang.org/doc/man/erlang.html#spawn-4 for
-  the list of available options.
-  """
-  @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 exists,
-  a useless pid is returned.
-
-  Check http://www.erlang.org/doc/man/erlang.html#spawn_opt-5 for
-  the list of available options.
-  """
-  @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 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).
-  """
-  @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 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).
-  """
-  @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`, 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, if the node is alive;
-  otherwise `:nocookie`.
-  """
-  def get_cookie() do
-    :erlang.get_cookie()
-  end
-end
@@ -1,172 +0,0 @@
-defmodule OptionParser do
-  @doc """
-  Parses the argv and returns one tuple with parsed options
-  and the arguments.
-
-  ## Examples
-
-      iex> OptionParser.parse(["--debug"])
-      { [debug: true], [] }
-
-      iex> OptionParser.parse(["--source", "lib"])
-      { [source: "lib"], [] }
-
-      iex> OptionParser.parse(["--source", "lib", "test/enum_test.exs", "--verbose"])
-      { [source: "lib", verbose: true], ["test/enum_test.exs"] }
-
-  ## Aliases
-
-  A set of aliases can be given as second argument:
-
-      iex> OptionParser.parse(["-d"], aliases: [d: :debug])
-      { [debug: true], [] }
-
-  ## Switches
-
-  Extra information about switches can be given as argument too.
-  This is useful in order to say a switch must behave as a boolean
-  or if duplicated switches should be kept, overriden or accumulated.
-
-  The following types are supported:
-
-  * `:boolean` - Mark the given switch as boolean. Boolean switches
-                 never consumes the following value unless it is
-                 true or false;
-
-  The following extra options are supported:
-
-  * `:keep` - Keep duplicated items in the list instead of overriding;
-
-  Examples:
-
-      iex> OptionParser.parse(["--unlock", "path/to/file"], switches: [unlock: :boolean])
-      { [unlock: true], ["path/to/file"] }
-
-      iex> OptionParser.parse(["--unlock", "false", "path/to/file"], switches: [unlock: :boolean])
-      { [unlock: false], ["path/to/file"] }
-
-  ## Negation switches
-
-  Any switches starting with `--no-` are always considered to be
-  booleans and never parse the next value:
-
-      iex> OptionParser.parse(["--no-op", "path/to/file"])
-      { [no_op: true], ["path/to/file"] }
-
-  """
-  def parse(argv, opts // []) when is_list(argv) and is_list(opts) do
-    parse(argv, opts, true)
-  end
-
-  @doc """
-  Similar to parse but only parses the head of the argv.
-  I.e. as soon as it finds a non switch, it stops parsing.
-
-  Check `parse/2` for more info.
-
-  ## Example
-
-      iex> OptionParser.parse_head(["--source", "lib", "test/enum_test.exs", "--verbose"])
-      { [source: "lib"], ["test/enum_test.exs", "--verbose"] }
-
-  """
-  def parse_head(argv, opts // []) when is_list(argv) and is_list(opts) do
-    parse(argv, opts, false)
-  end
-
-  ## Helpers
-
-  defp parse(argv, opts, bool) do
-    aliases  = opts[:aliases]  || []
-    switches = opts[:switches] || []
-    parse(argv, aliases, switches, bool)
-  end
-
-  defp parse(argv, aliases, switches, all) do
-    parse(argv, aliases, switches, [], [], all)
-  end
-
-  defp parse(["-" <> option|t], aliases, switches, dict, args, all) do
-    { option, value } = normalize_option(option, aliases)
-    kind = switches[option]
-
-    if value == nil do
-      { value, t } =
-        if is_switch_a? :boolean, kind do
-          boolean_from_tail(t)
-        else
-          value_from_tail(t)
-        end
-    end
-
-    dict = store_option dict, option, value, kind
-    parse(t, aliases, switches, dict, args, all)
-  end
-
-  defp parse([h|t], aliases, switches, dict, args, true) do
-    parse(t, aliases, switches, dict, [h|args], true)
-  end
-
-  defp parse([], _, switches, dict, args, true) do
-    { reverse_dict(dict, switches), Enum.reverse(args) }
-  end
-
-  defp parse(value, _, switches, dict, _args, false) do
-    { reverse_dict(dict, switches), value }
-  end
-
-  defp boolean_from_tail([h|t]) when h in ["false", "true"], do: { h, t }
-  defp boolean_from_tail(t)                                , do: { true, t }
-
-  defp value_from_tail(["-" <> _|_] = t), do: { true, t }
-  defp value_from_tail([h|t]),            do: { h, t }
-  defp value_from_tail([]),               do: { true, [] }
-
-  defp store_option(dict, option, value, switches) when value in ["true", "false"] do
-    store_option dict, option, binary_to_atom(value), switches
-  end
-
-  defp store_option(dict, option, value, kind) do
-    if is_switch_a? :keep, kind do
-      [{ option, value }|dict]
-    else
-      [{ option, value }|Keyword.delete(dict, option)]
-    end
-  end
-
-  defp reverse_dict(dict, switches) do
-    switches = lc { k, v } inlist switches,
-                  is_switch_a?(:boolean, v),
-                  not Keyword.has_key?(dict, k), do: { k, false }
-    Enum.reverse switches ++ dict
-  end
-
-  defp normalize_option(<<?-, option :: binary>>, aliases) do
-    normalize_option(option, aliases)
-  end
-
-  defp normalize_option(option, aliases) do
-    { option, value } = split_option(option)
-    if is_no?(option), do: value = true
-    atom = option |> to_underscore |> binary_to_atom
-    { aliases[atom] || atom, value }
-  end
-
-  defp split_option(option) do
-    case :binary.split(option, "=") do
-      [h]   -> { h, nil }
-      [h|t] -> { h, Enum.join(t, "=") }
-    end
-  end
-
-  defp to_underscore(option) do
-    bc <<c>> inbits option, do: << if c == ?-, do: ?_, else: c >>
-  end
-
-  defp is_no?("no-" <> _), do: true
-  defp is_no?(_),          do: false
-
-  defp is_switch_a?(kind, list) when is_list(list), do: kind in list
-  defp is_switch_a?(kind, kind), do: true
-  defp is_switch_a?(_, _),       do: false
-end
@@ -1,534 +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 char list or
-  a binary as argument and will return a value of the same
-  type.
-
-  The majority of the functions in this module do not
-  interact with the file system, except for a few functions
-  that require it (like `Path.wildcard` and `Path.expand`).
-  """
-
-  alias :filename, as: FN
-
-  @type t :: char_list | atom | binary
-  @type r :: char_list | binary
-
-  @doc """
-  Converts the given path to an absolute one. Differently from
-  `Path.expand/1`, no attempt is made to resolve `..`, `.` or `~`.
-
-  ## Unix examples
-
-      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"
-
-  """
-  def absname(path) do
-    FN.absname(path, get_cwd(path))
-  end
-
-  @doc """
-  Builds a path from `relative_to` to `path`. If `path` is already
-  an absolute path, `relative_to` is ignored. See also `Path.relative/2`.
-
-  Differently from `Path.expand/2`, no attempt is made to
-  resolve `..`, `.` or `~`.
-
-  ## Examples
-
-      iex> Path.absname("foo", "bar")
-      "bar/foo"
-
-      iex> Path.absname("../x", "bar")
-      "bar/../x"
-
-  """
-  def absname(path, relative_to) do
-    FN.absname(path, relative_to)
-  end
-
-  @doc """
-  Converts the path to an absolute one and expands
-  any `.` and `..` characters and a leading `~`.
-
-  ## Examples
-
-      iex> Path.expand("/foo/bar/../bar")
-      "/foo/bar"
-
-  """
-  def expand(path) do
-    normalize FN.absname(expand_home(path), get_cwd(path))
-  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 `path` with 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"
-
-      iex> Path.expand("foo/bar/../bar", "/baz")
-      "/baz/foo/bar"
-      iex> Path.expand("/foo/bar/../bar", "/baz")
-      "/foo/bar"
-
-  """
-  def expand(path, relative_to) do
-    normalize FN.absname(FN.absname(expand_home(path), expand_home(relative_to)), get_cwd(path))
-  end
-
-  @doc """
-  Returns the path type.
-
-  ## Unix examples
-
-      Path.type("/usr/local/bin")   #=> :absolute
-      Path.type("usr/local/bin")    #=> :relative
-      Path.type("../usr/local/bin") #=> :relative
-      Path.type("~/file")           #=> :relative
-
-  ## Windows examples
-
-      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
-
-  """
-  def type(name) when is_list(name) or is_binary(name) do
-    case :os.type() do
-      { :win32, _ } -> win32_pathtype(name)
-      _             -> unix_pathtype(name)
-    end |> elem(0)
-  end
-
-  @doc """
-  Forces the path to be a relative path.
-
-  ## Unix examples
-
-      Path.relative("/usr/local/bin")   #=> "usr/local/bin"
-      Path.relative("usr/local/bin")    #=> "usr/local/bin"
-      Path.relative("../usr/local/bin") #=> "../usr/local/bin"
-
-  ## Windows examples
-
-      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"
-
-  """
-  def relative(name) do
-    case :os.type() do
-      { :win32, _ } -> win32_pathtype(name)
-      _             -> unix_pathtype(name)
-    end |> elem(1)
-  end
-
-  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([atom|rest]) when is_atom(atom), do:
-    unix_pathtype(atom_to_list(atom) ++ 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([atom|rest]) when is_atom(atom), do:
-    win32_pathtype(atom_to_list(atom)++rest)
-  defp win32_pathtype([char, list|rest]) when is_list(list), do:
-    win32_pathtype([char|list++rest])
-  defp win32_pathtype(<<c1, c2, relative :: binary>>) when c1 in @slash and c2 in @slash, do:
-    { :absolute, relative }
-  defp win32_pathtype(<<c, relative :: binary>>) when c in @slash, do:
-    { :volumerelative, relative }
-  defp win32_pathtype(<<_letter, ?:, c, relative :: binary>>) when c in @slash, do:
-    { :absolute, relative }
-  defp win32_pathtype(<<_letter, ?:, relative :: binary>>), do:
-    { :volumerelative, relative }
-
-  defp win32_pathtype([c1, c2 | relative]) when c1 in @slash and c2 in @slash, do:
-    { :absolute, relative }
-  defp win32_pathtype([c | relative]) when c in @slash, do:
-    { :volumerelative, relative }
-  defp win32_pathtype([c1, c2, list|rest]) when is_list(list), do:
-    win32_pathtype([c1, c2|list++rest])
-  defp win32_pathtype([_letter, ?:, c | relative]) when c in @slash, do:
-    { :absolute, relative }
-  defp win32_pathtype([_letter, ?: | relative]), do:
-    { :volumerelative, relative }
-  defp win32_pathtype(relative), do:
-    { :relative, relative }
-
-  @doc """
-  Returns the given `path` relative to the given `from` path.
-  In other words, it tries to strip the `from` prefix from `path`.
-
-  This function does not query the file system, so it assumes
-  no symlinks in 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"
-
-  """
-  def relative_to(path, from) when is_list(path) and is_binary(from) do
-    path = filename_string_to_binary(path)
-    relative_to(FN.split(path), FN.split(from), path)
-  end
-
-  def relative_to(path, from) when is_binary(path) and is_list(from) do
-    relative_to(FN.split(path), FN.split(filename_string_to_binary(from)), path)
-  end
-
-  def relative_to(path, from) do
-    relative_to(FN.split(path), FN.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
-    FN.join(l1)
-  end
-
-  defp relative_to(_, _, original) do
-    original
-  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("/")
-      ""
-
-  """
-  def basename(path) do
-    FN.basename(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"
-
-  """
-  def basename(path, extension) do
-    FN.basename(path, extension)
-  end
-
-  @doc """
-  Returns the directory component of `path`.
-
-  ## Examples
-
-      Path.dirname("/foo/bar.ex")
-      #=> "/foo"
-      Path.dirname("/foo/bar/baz.ex")
-      #=> "/foo/bar"
-
-  """
-  def dirname(path) do
-    FN.dirname(path)
-  end
-
-  @doc """
-  Returns the extension of the last component of `path`.
-
-  ## Examples
-
-      iex> Path.extname("foo.erl")
-      ".erl"
-      iex> Path.extname("~/foo/bar")
-      ""
-
-  """
-  def extname(path) do
-    FN.extension(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"
-
-  """
-  def rootname(path) do
-    FN.rootname(path)
-  end
-
-  @doc """
-  Returns the `path` with the `extension` stripped. This function should be used to
-  remove a specific extension which might, or might not, be there.
-
-  ## Examples
-
-      iex> Path.rootname("/foo/bar.erl", ".erl")
-      "/foo/bar"
-      iex> Path.rootname("/foo/bar.erl", ".ex")
-      "/foo/bar.erl"
-
-  """
-  def rootname(path, extension) do
-    FN.rootname(path, extension)
-  end
-
-  @doc """
-  Returns a string with one or more path components joined by the path separator.
-  This function should be used to convert a list of strings to a path.
-
-  ## Examples
-
-      iex> Path.join(["~", "foo"])
-      "~/foo"
-      iex> Path.join(["foo"])
-      "foo"
-      iex> Path.join(["/", "foo", "bar"])
-      "/foo/bar"
-
-  """
-  def join([name1, name2|rest]), do:
-    join([join(name1, name2)|rest])
-  def join([name]) when is_list(name), do:
-    binary_to_filename_string(do_join(filename_string_to_binary(name), <<>>, [], major_os_type()))
-  def join([name]) when is_binary(name), do:
-    do_join(name, <<>>, [], major_os_type())
-
-  @doc """
-  Joins two paths.
-
-  ## Examples
-
-      iex> Path.join("foo", "bar")
-      "foo/bar"
-
-  """
-  def join(left, right) when is_binary(left) and is_binary(right), do:
-    do_join(left, Path.relative(right), [], major_os_type())
-
-  def join(left, right) when is_binary(left) and is_list(right), do:
-    join(left, filename_string_to_binary(right))
-
-  def join(left, right) when is_list(left) and is_binary(right), do:
-    join(filename_string_to_binary(left), right)
-
-  def join(left, right) when is_list(left) and is_list(right), do:
-    binary_to_filename_string join(filename_string_to_binary(left), filename_string_to_binary(right))
-
-  def join(left, right) when is_atom(left), do:
-    join(atom_to_binary(left), right)
-
-  def join(left, right) when is_atom(right), do:
-    join(left, atom_to_binary(right))
-
-  defp major_os_type do
-    :os.type |> elem(0)
-  end
-
-  defp do_join(<<uc_letter, ?:, rest :: binary>>, relativename, [], :win32) when uc_letter in ?A..?Z, do:
-    do_join(rest, relativename, [?:, uc_letter+?a-?A], :win32)
-  defp do_join(<<?\\,rest :: binary>>, relativename, result, :win32), do:
-    do_join(<<?/,rest :: binary>>, relativename, result, :win32)
-  defp do_join(<<?/,rest :: binary>>, relativename, [?., ?/|result], os_type), do:
-    do_join(rest, relativename, [?/|result], os_type)
-  defp do_join(<<?/,rest :: binary>>, relativename, [?/|result], os_type), do:
-    do_join(rest, relativename, [?/|result], os_type)
-  defp do_join(<<>>, <<>>, result, os_type), do:
-    list_to_binary(maybe_remove_dirsep(result, os_type))
-  defp do_join(<<>>, relativename, [?:|rest], :win32), do:
-    do_join(relativename, <<>>, [?:|rest], :win32)
-  defp do_join(<<>>, relativename, [?/|result], os_type), do:
-    do_join(relativename, <<>>, [?/|result], os_type)
-  defp do_join(<<>>, relativename, result, os_type), do:
-    do_join(relativename, <<>>, [?/|result], os_type)
-  defp do_join(<<char,rest :: binary>>, relativename, result, os_type) when is_integer(char), do:
-    do_join(rest, relativename, [char|result], os_type)
-
-  defp maybe_remove_dirsep([?/, ?:, letter], :win32), do:
-    [letter, ?:, ?/]
-  defp maybe_remove_dirsep([?/], _), do:
-    [?/]
-  defp maybe_remove_dirsep([?/|name], _), do:
-    :lists.reverse(name)
-  defp maybe_remove_dirsep(name, _), do:
-    :lists.reverse(name)
-
-  @doc """
-  Returns a list with the path split by the path separator.
-  If an empty string is given, returns the root path.
-
-  ## Examples
-
-       iex> Path.split("")
-       []
-       iex> Path.split("foo")
-       ["foo"]
-       iex> Path.split("/foo/bar")
-       ["/", "foo", "bar"]
-
-  """
-  # Work around a bug in Erlang on UNIX
-  def split(""), do: []
-
-  def split(path) do
-    FN.split(path)
-  end
-
-  @doc """
-  Traverses paths according to the given `glob` expression.
-
-  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 <c>*</c>'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.
-  * `{item1,item2,...}` - Matches one of the alternatives.
-
-  Other characters represent themselves. Only paths that have
-  exactly the same character in the same position will match. Note
-  that matching is case-sensitive; i.e. "a" will not match "A".
-
-  ## Examples
-
-  Imagine you have a directory called `projects` with three Elixir projects
-  inside of it: `elixir`, `ex_doc` and `dynamo`. You can find all `.beam` files
-  inside the ebin directory of each project as follows:
-
-      Path.wildcard("projects/*/ebin/**/*.beam")
-
-  If you want to search for both `.beam` and `.app` files, you could do:
-
-      Path.wildcard("projects/*/ebin/**/*.{beam,app}")
-
-  """
-  def wildcard(glob) when is_binary(glob) do
-    paths = :filelib.wildcard :unicode.characters_to_list(glob)
-    Enum.map paths, :unicode.characters_to_binary(&1)
-  end
-
-  def wildcard(glob) when is_list(glob) do
-    :filelib.wildcard glob
-  end
-
-  ## Helpers
-
-  defp get_cwd(path) when is_list(path), do: System.cwd! |> binary_to_filename_string
-  defp get_cwd(_), do: System.cwd!
-
-  defp binary_to_filename_string(binary) do
-    case :unicode.characters_to_list(binary) do
-      { :error, _, _ } ->
-        :erlang.error(:badarg)
-      list when is_list(list) ->
-        list
-    end
-  end
-
-  defp filename_string_to_binary(list) do
-    case :unicode.characters_to_binary(:filename.flatten(list), :unicode, :file.native_name_encoding()) do
-      { :error, _, _ } ->
-        :erlang.error(:badarg)
-      bin when is_binary(bin) ->
-        bin
-    end
-  end
-
-  # Normalize the given path by expanding "..", "." and "~".
-
-  defp expand_home(<<?~, rest :: binary>>) do
-    System.user_home! <> rest
-  end
-
-  defp expand_home('~' ++ rest) do
-    (System.user_home! |> binary_to_filename_string) ++ rest
-  end
-
-  defp expand_home(other), do: other
-
-  defp normalize(path), do: normalize(FN.split(path), [])
-
-  defp normalize([top|t], [_|acc]) when top in ["..", '..'] do
-    normalize t, acc
-  end
-
-  defp normalize([top|t], acc) when top in [".", '.'] do
-    normalize t, acc
-  end
-
-  defp normalize([h|t], acc) do
-    normalize t, [h|acc]
-  end
-
-  defp normalize([], acc) do
-    join Enum.reverse(acc)
-  end
-end
@@ -1,68 +0,0 @@
-defmodule Port do
-  @moduledoc """
-  Functions related to Erlang ports.
-  """
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#open_port-2.
-  """
-  def open(name, settings) do
-    :erlang.open_port(name, settings)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_close-1.
-  """
-  def close(port) do
-    :erlang.port_close(port)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_command-2.
-  """
-  def command(port, data, options // []) do
-    :erlang.port_command(port, data, options)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_connect-2.
-  """
-  def connect(port, pid) do
-    :erlang.port_connect(port, pid)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_control-3.
-  """
-  def control(port, operation, data) do
-    :erlang.port_control(port, operation, data)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_call-3.
-  """
-  def call(port, operation, data) do
-    :erlang.port_call(port, operation, data)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_info-1.
-  """
-  def info(port) do
-    :erlang.port_info(port)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#port_info-2.
-  """
-  def info(port, item) do
-    :erlang.port_info(port, item)
-  end
-
-  @doc """
-  See http://www.erlang.org/doc/man/erlang.html#ports-0.
-  """
-  def list do
-    :erlang.ports
-  end
-end
@@ -1,366 +0,0 @@
-defmodule Process do
-  @moduledoc """
-  This module provides convenience functions around processes and
-  the process dictionary. In Erlang, most of these functions are
-  auto-imported, but in Elixir they are grouped in a module for
-  convenience. Notice that these functions, different from Erlang's,
-  always return nil instead of undefined. You can use their Erlang
-  version if you want the undefined value.
-  """
-
-  @doc """
-  Returns true if the process exists and is alive, that is,
-  is not exiting and has not exited. Otherwise, returns false.
-
-  `pid` must refer to a process at the local node.
-  """
-  @spec alive?(pid) :: boolean
-  def alive?(pid) do
-    :erlang.is_process_alive(pid)
-  end
-
-  @doc """
-  Returns all key-values in the dictionary.
-  """
-  @spec get :: [{term, term}]
-  def get do
-    :erlang.get()
-  end
-
-  @doc """
-  Returns the value for the given key.
-  """
-  @spec get(term) :: term
-  @spec get(term, default :: term) :: term
-  def get(key, default // nil) do
-    case :erlang.get(key) do
-      :undefined ->
-        default
-      value ->
-        value
-    end
-  end
-
-  @doc """
-  Returns all keys that have the given `value`.
-  """
-  @spec get_keys(term) :: [term]
-  def get_keys(value) do
-    :erlang.get_keys(value)
-  end
-
-  @doc """
-  Stores the given key-value in the process dictionary.
-  """
-  @spec put(term, term) :: term | nil
-  def put(key, value) do
-    nillify :erlang.put(key, value)
-  end
-
-  @doc """
-  Deletes all items in the dictionary.
-  """
-  @spec delete :: [{term, term}]
-  def delete() do
-    :erlang.erase()
-  end
-
-  @doc """
-  Deletes the given key from the dictionary.
-  """
-  @spec delete(term) :: term | nil
-  def delete(key) do
-    nillify :erlang.erase(key)
-  end
-
-  @doc """
-  Sends an exit signal with the given reason to the pid.
-
-  The following behavior apply if reason is any term except `:normal` or `:kill`:
-
-  1) If pid is not trapping exits, pid itself will exist 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;
-
-  3) If reason is the atom `:normal`, pid will not exit. If it is trapping exits,
-     the exit signal is transformed into a message {'EXIT', from, :normal} and
-     delivered to its message queue;
-
-  4) If reason is the atom `:kill`, that is if `exit(pid, :kill)` is called, an
-     untrappable exit signal is sent to pid which will unconditionally exit with
-     exit reason `:killed`.
-
-  ## Examples
-
-      Process.exit(pid, :kill)
-
-  """
-  @spec exit(pid, term) :: true
-  def exit(pid, reason) do
-    :erlang.exit(pid, reason)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of `fun`.
-  It behaves exactly the same as `Kernel.spawn/1`.
-  """
-  @spec spawn((() -> any)) :: pid
-  def spawn(fun) do
-    :erlang.spawn(fun)
-  end
-
-  @type spawn_opt  :: :link | :monitor | {:priority, :low | :normal | :high} |
-                      {:fullsweep_after, non_neg_integer} |
-                      {:min_heap_size, non_neg_integer} |
-                      {:min_bin_vheap_size, non_neg_integer}
-  @type spawn_opts :: [spawn_opt]
-
-  @doc """
-  Returns the pid of a new process started by the application of `fun`.
-
-  It also accepts extra options, for the list of available options
-  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-2
-  """
-  @spec spawn((() -> any), spawn_opts) :: pid | {pid, reference}
-  def spawn(fun, opts) do
-    :erlang.spawn_opt(fun, opts)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of
-  `module.function(args)`. The new process created will be placed in the system
-  scheduler queue and be run some time later.
-
-  It behaves exactly the same as the `Kernel.spawn/3` function.
-  """
-  @spec spawn(module, atom, [any]) :: pid
-  def spawn(mod, fun, args) do
-    :erlang.spawn(mod, fun, args)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of
-  `module.function(args)`. The new process created will be placed in the system
-  scheduler queue and be run some time later.
-
-  It also accepts extra options, for the list of available options
-  check http://www.erlang.org/doc/man/erlang.html#spawn_opt-4
-
-  """
-  @spec spawn(module, atom, [any], spawn_opts) :: pid | {pid, reference}
-  def spawn(mod, fun, args, opts) do
-    :erlang.spawn_opt(mod, fun, args, opts)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of `fun`.
-  A link is created between the calling process and the new
-  process, atomically.
-  """
-  @spec spawn_link((() -> any)) :: pid
-  def spawn_link(fun) do
-    :erlang.spawn_link(fun)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of
-  `module.function(args)`. A link is created between the calling process
-  and the new process, atomically. Otherwise works like spawn/3.
-  """
-  @spec spawn_link(module, atom, [any]) :: pid
-  def spawn_link(mod, fun, args) do
-    :erlang.spawn_link(mod, fun, args)
-  end
-
-  @doc """
-  Returns the pid of a new process started by the application of `fun`
-  and reference for a monitor created to the new process.
-  """
-  @spec spawn_monitor((() -> any)) :: {pid, reference}
-  def spawn_monitor(fun) do
-    :erlang.spawn_monitor(fun)
-  end
-
-  @doc """
-  A new process is started by the application of `module.function(args)`
-  and the process is monitored at the same time. Returns the pid and a
-  reference for the monitor. Otherwise works like spawn/3.
-  """
-  @spec spawn_monitor(module, atom, [any]) :: {pid, reference}
-  def spawn_monitor(mod, fun, args) do
-    :erlang.spawn_monitor(mod, fun, args)
-  end
-
-  @doc """
-  The calling process starts monitoring the item given.
-  It returns the monitor reference.
-
-  See http://www.erlang.org/doc/man/erlang.html#monitor-2 for more info.
-  """
-  @spec monitor(pid | {reg_name :: atom, node :: atom} | reg_name :: atom) :: reference
-  def monitor(item) do
-    :erlang.monitor(:process, item)
-  end
-
-  @doc """
-  If monitor_ref is a reference which the calling process
-  obtained by calling monitor/1, this monitoring is turned off.
-  If the monitoring is already turned off, nothing happens.
-
-  See http://www.erlang.org/doc/man/erlang.html#demonitor-2 for more info.
-  """
-  @spec demonitor(reference) :: true
-  @spec demonitor(reference, options :: [:flush | :info]) :: boolean
-  def demonitor(monitor_ref, options // []) do
-    :erlang.demonitor(monitor_ref, options)
-  end
-
-  @doc """
-  Returns a list of process identifiers corresponding to all the
-  processes currently existing on the local node.
-
-  Note that a process that is exiting, exists but is not alive, i.e.,
-  alive?/1 will return false for a process that is exiting,
-  but its process identifier will be part of the result returned.
-
-  See http://www.erlang.org/doc/man/erlang.html#processes-0 for more info.
-  """
-  @spec list :: [pid]
-  def list do
-    :erlang.processes()
-  end
-
-  @doc """
-  Creates a link between the calling process and another process
-  (or port) `pid`, if there is not such a link already.
-
-  See http://www.erlang.org/doc/man/erlang.html#link-1 for more info.
-  """
-  @spec link(pid | port) :: true
-  def link(pid) do
-    :erlang.link(pid)
-  end
-
-  @doc """
-  Removes the link, if there is one, between the calling process and
-  the process or port referred to by `pid`. Returns true and does not
-  fail, even if there is no link or `id` does not exist
-
-  See http://www.erlang.org/doc/man/erlang.html#unlink-1 for more info.
-  """
-  @spec unlink(pid | port) :: true
-  def unlink(pid) do
-    :erlang.unlink(pid)
-  end
-
-  @doc """
-  Associates the name with a pid or a port identifier. name, which must
-  be an atom, can be used instead of the pid / port identifier in the
-  send operator (name <- message).
-
-  See http://www.erlang.org/doc/man/erlang.html#register-2 for more info.
-  """
-  @spec register(pid | port, atom) :: true
-  def register(pid, name) do
-    :erlang.register(name, pid)
-  end
-
-  @doc """
-  Removes the registered name, associated with a pid or a port identifier.
-
-  See http://www.erlang.org/doc/man/erlang.html#unregister-1 for more info.
-  """
-  @spec unregister(atom) :: true
-  def unregister(name) do
-    :erlang.unregister(name)
-  end
-
-  @doc """
-  Returns the pid or port identifier with the registered name.
-  Returns undefined if the name is not registered.
-
-  See 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 process which evaluates the function.
-  """
-  @spec group_leader :: pid
-  def group_leader do
-    :erlang.group_leader
-  end
-
-  @doc """
-  Sets the group leader of Pid to GroupLeader. Typically, this is used when a processes
-  started from a certain shell should have another group leader than `:init`.
-  """
-  @spec group_leader(leader :: pid, pid) :: true
-  def group_leader(leader, pid) do
-    :erlang.group_leader(leader, pid)
-  end
-
-  @doc """
-  Returns a list of names which have been registered using register/2.
-  """
-  @spec registered :: [atom]
-  def registered do
-    :erlang.registered()
-  end
-
-  @typep process_flag :: :trap_exit | :error_handler | :min_heap_size |
-                         :min_bin_vheap_size | :priority | :save_calls |
-                         :sensitive
-  @doc """
-  Sets certain flags for the process which calls this function.
-  Returns the old value of the flag.
-
-  See http://www.erlang.org/doc/man/erlang.html#process_flag-2 for more info.
-  """
-  @spec flag(process_flag, term) :: term
-  def flag(flag, value) do
-    :erlang.process_flag(flag, value)
-  end
-
-  @doc """
-  Sets certain flags for the process Pid, in the same manner as flag/2.
-  Returns the old value of the flag. The allowed values for Flag are
-  only a subset of those allowed in flag/2, namely: save_calls.
-
-  See http://www.erlang.org/doc/man/erlang.html#process_flag-3 for more info.
-  """
-  @spec flag(pid, process_flag, term) :: term
-  def flag(pid, flag, value) do
-    :erlang.process_flag(pid, flag, value)
-  end
-
-  @doc """
-  Returns information about the process identified by pid.
-  Use this only for debugging information.
-
-  See http://www.erlang.org/doc/man/erlang.html#process_info-1 for more info.
-  """
-  @spec info(pid) :: Keyword.t
-  def info(pid) do
-    :erlang.process_info(pid)
-  end
-
-  @doc """
-  Returns information about the process identified by pid
-  or undefined if the process is not alive.
-
-  See http://www.erlang.org/doc/man/erlang.html#process_info-2 for more info.
-  """
-  @spec info(pid, atom) :: {atom, term}
-  def info(pid, spec) do
-    :erlang.process_info(pid, spec)
-  end
-
-  @compile { :inline, nillify: 1 }
-  defp nillify(:undefined), do: nil
-  defp nillify(other),      do: other
-end
@@ -1,418 +0,0 @@
-defmodule Protocol do
-  @moduledoc false
-
-  # We need to use :lists because Enum is not available yet
-  require :lists, as: L
-
-  @doc """
-  Handle `defprotocol`. It will define a function for each
-  protocol plus two extra functions:
-
-  * `__protocol__/1` - returns the protocol name when :name is given,
-                       and a keyword list with the protocol functions
-                       when :functions is given;
-
-  * `__impl_for__/1` - receives one argument and returns a module
-                       that implements the protocol for the given
-                       data type. If no implementation matches, returns nil;
-
-  * `__impl_for__!/1` - same as above but raises an error if an implementation is not found
-  """
-  def defprotocol(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, defmacrop: 4,
-          defmacro: 1, defmacro: 2, defmacro: 4,
-          defp: 1, defp: 2, defp: 4,
-          def: 1, def: 2, def: 4
-        ]
-
-        # Import the new dsl that holds the new def
-        import :macros, Protocol.DSL
-
-        # Set up a clear slate to store defined functions
-        @functions []
-
-        # Invoke the user given block
-        unquote(block)
-
-        # Define callbacks and meta information
-        { conversions, fallback, returns_nil } = Protocol.conversions_for(__MODULE__, @only, @except)
-        Protocol.impl_for(conversions, fallback, returns_nil, __ENV__)
-        Protocol.meta(@functions, conversions, fallback, returns_nil, __ENV__)
-      end
-    end
-  end
-
-  @doc """
-  Implement the given protocol for the given module.
-  It also defines a `__impl__` function which
-  returns the protocol being implemented.
-  """
-  def defimpl(protocol, opts) do
-    do_defimpl(protocol, :lists.keysort(1, opts))
-  end
-
-  defp do_defimpl(protocol, [do: block, for: for]) when is_list(for) do
-    lc f inlist for, do: do_defimpl(protocol, [do: block, for: f])
-  end
-
-  defp do_defimpl(protocol, [do: block, for: for]) do
-    quote do
-      protocol = unquote(protocol)
-      for      = unquote(for)
-      name     = Module.concat(protocol, for)
-
-      Protocol.assert_protocol(protocol)
-
-      defmodule name do
-        @behaviour unquote(protocol)
-        unquote(block)
-        def __impl__, do: unquote(protocol)
-      end
-    end
-  end
-
-  # Check if the given module is a protocol. Raises an error
-  # if not loaded or not a protocol.
-  @doc false
-  def assert_protocol(module) do
-    case Code.ensure_compiled(module) do
-      { :module, ^module } -> nil
-      _ -> raise ArgumentError, message: "#{module} is not loaded"
-    end
-
-    try do
-      module.__protocol__(:name)
-    rescue
-      UndefinedFunctionError ->
-        raise ArgumentError, message: "#{module} is not a protocol"
-    end
-  end
-
-  # Implements the function that detects the protocol and returns
-  # the module to dispatch to. Returns module.Record for records
-  # which should be properly handled by the dispatching function.
-  @doc false
-  def impl_for(conversions, fallback, returns_nil, env) do
-    contents = lc kind inlist conversions do
-      each_impl_for(kind, conversions, fallback)
-    end
-
-    if returns_nil do
-      contents = contents ++ [quote do
-        defp __raw_impl__(_) do
-          nil
-        end
-      end]
-    end
-
-    Module.eval_quoted env.module, contents, [], env.location
-  end
-
-  # Defines meta information about the protocol and internal callbacks.
-  @doc false
-  def meta(functions, conversions, fallback, returns_nil, env) do
-    any     = L.keyfind(Any, 1, conversions) != false
-    records = L.keyfind(Record, 1, conversions) != false
-
-    meta = quote location: :keep do
-      unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
-        @type t :: unquote(generate_type(conversions, any))
-      end
-
-      @doc false
-      def __protocol__(:name),      do: __MODULE__
-      def __protocol__(:functions), do: unquote(:lists.sort(functions))
-    end
-
-    impl_for = cond do
-      records and fallback ->
-        quote location: :keep do
-          def __impl_for__(arg) do
-            case __raw_impl__(arg) do
-              __MODULE__.Record ->
-                target = Module.concat(__MODULE__, :erlang.element(1, arg))
-                try do
-                  target.__impl__
-                  target
-                catch
-                  :error, :undef, [[{ ^target, :__impl__, [], _ }|_]|_] ->
-                    unquote(fallback)
-                end
-              other ->
-                other
-            end
-          end
-        end
-      records ->
-        quote location: :keep do
-          def __impl_for__(arg) do
-            case __raw_impl__(arg) do
-              __MODULE__.Record ->
-                Module.concat(__MODULE__, :erlang.element(1, arg))
-              other ->
-                other
-            end
-          end
-        end
-      true ->
-        quote location: :keep do
-          def __impl_for__(arg), do: __raw_impl__(arg)
-        end
-    end
-
-    impl_bang = if returns_nil do
-      quote do
-        def __impl_for__!(arg) do
-          __impl_for__(arg) || raise(Protocol.UndefinedError, protocol: __MODULE__, structure: arg)
-        end
-      end
-    else
-      quote do
-        def __impl_for__!(arg), do: __impl_for__(arg)
-      end
-    end
-
-    Module.eval_quoted env.module, [meta, impl_for, impl_bang], [], env.location
-  end
-
-  # Returns the default conversions according to the given
-  # only/except options.
-  @doc false
-  def conversions_for(module, only, except) do
-    kinds = all_types
-
-    conversions =
-      if only do
-        L.map(fn i -> L.keyfind(i, 1, kinds) end, only)
-      else
-        except = except || [Any]
-        L.foldl(fn i, list -> L.keydelete(i, 1, list) end, kinds, except)
-      end
-
-    fallback = cond do
-      L.keyfind(Tuple, 1, conversions) ->
-        Module.concat module, Tuple
-      L.keyfind(Any, 1, conversions) ->
-        Module.concat module, Any
-      true ->
-        nil
-    end
-
-    # If any is not in the list and we don't implement all
-    # protocols, we need to handle nil cases.
-    returns_nil = L.keyfind(Any, 1, conversions) == false and length(conversions) < 10
-    { conversions, fallback, returns_nil }
-  end
-
-  ## Helpers
-
-  defp generate_type(_conversions, true) do
-    quote(do: any)
-  end
-
-  defp generate_type(conversions, false) do
-    or_function     = fn({ _, _, x }, acc) -> { :|, [], [acc, x] } end
-    { _, _, first } = hd(conversions)
-    :lists.foldl(or_function, first, tl(conversions))
-  end
-
-  defp all_types do
-    [ { Record,    :is_record,    quote do: tuple },
-      { Tuple,     :is_tuple,     quote do: tuple },
-      { Atom,      :is_atom,      quote do: atom },
-      { List,      :is_list,      quote do: list },
-      { BitString, :is_bitstring, quote do: <<>> },
-      { Number,    :is_number,    quote do: number },
-      { Function,  :is_function,  quote do: (... -> any) },
-      { PID,       :is_pid,       quote do: pid },
-      { Port,      :is_port,      quote do: port },
-      { Reference, :is_reference, quote do: reference },
-      { Any,       :is_any,       quote do: any } ]
-  end
-
-  # Returns a quoted expression that allows to check
-  # if the first item in the tuple is a built-in or not.
-  defp is_builtin?([{h,_,_}]) do
-    quote do
-      first == unquote(h)
-    end
-  end
-
-  defp is_builtin?([{h,_,_}|t]) do
-    quote do
-      first == unquote(h) or unquote(is_builtin?(t))
-    end
-  end
-
-  # We don't have a fallback, so we assume what was given
-  # as a record is indeed a record
-  defp each_impl_for({ _, :is_record, _ }, _conversions, nil) do
-    quote do
-      defp __raw_impl__(arg) when is_record(arg) do
-        __MODULE__.Record
-      end
-    end
-  end
-
-  # Specially handle records in the case we have fallbacks.
-  defp each_impl_for({ _, :is_record, _ }, conversions, fallback) do
-    quote do
-      defp __raw_impl__(arg) when is_record(arg) do
-        first = :erlang.element(1, arg)
-        case unquote(is_builtin?(conversions)) do
-          true  -> unquote(fallback)
-          false ->
-            case atom_to_list(first) do
-              'Elixir.' ++ _ -> __MODULE__.Record
-              _              -> unquote(fallback)
-            end
-        end
-      end
-    end
-  end
-
-  # Special case any as we don't need to generate a guard.
-  defp each_impl_for({ _, :is_any, _ }, _, _) do
-    quote do
-      defp __raw_impl__(_) do
-        __MODULE__.Any
-      end
-    end
-  end
-
-  # Generate all others protocols.
-  defp each_impl_for({ kind, fun, _ }, _, _) do
-    quote do
-      defp __raw_impl__(arg) when unquote(fun)(arg) do
-        __MODULE__.unquote(kind)
-      end
-    end
-  end
-end
-
-defmodule Protocol.DSL do
-  @moduledoc false
-
-  # We need to use :lists because Enum is not available yet
-  require :lists, as: L
-
-  @doc false
-  def args_and_body(module, name, arity) do
-    # Generate arguments according the arity. The arguments
-    # are named xa, xb and so forth. We cannot use string
-    # interpolation to generate the arguments because of compile
-    # dependencies, so we use the <<>> instead.
-    args = lc i inlist :lists.seq(1, arity) do
-      { binary_to_atom(<<?x, i + 64>>), [], __MODULE__ }
-    end
-
-    { conversions, fallback, returns_nil } = conversions_for(module)
-    clauses = [default_clause(name, args)]
-
-    if returns_nil do
-      clauses = [nil_clause()|clauses]
-    end
-
-    if L.keyfind(Record, 1, conversions) do
-      clauses = [record_clause(name, args, fallback)|clauses]
-    end
-
-    body =
-      quote do
-        case __raw_impl__(xA), do: unquote({ :->, [], clauses })
-      end
-
-    { args, body }
-  end
-
-  @doc false
-  def callback_from_spec(module, name, arity) do
-    tuple = { name, arity }
-    specs = Module.get_attribute(module, :spec)
-
-    found = lc { k, v } inlist specs, k == tuple do
-      Kernel.Typespec.define_callback(module, tuple, v)
-      true
-    end
-
-    found != []
-  end
-
-  defp conversions_for(module) do
-    only   = Module.get_attribute(module, :only)
-    except = Module.get_attribute(module, :except)
-    Protocol.conversions_for(module, only, except)
-  end
-
-  defp default_clause(name, args) do
-    quote do: { [other], apply(other, unquote(name), [unquote_splicing(args)]) }
-  end
-
-  defp nil_clause() do
-    quote do
-      { [nil], raise(Protocol.UndefinedError, protocol: __MODULE__, structure: xA) }
-    end
-  end
-
-  defp record_clause(name, args, nil) do
-    quote do
-      { [__MODULE__.Record],
-        Module.concat(__MODULE__, :erlang.element(1, xA)).unquote(name)(unquote_splicing(args)) }
-    end
-  end
-
-  defp record_clause(name, args, fallback) do
-    arity = length(args)
-
-    quote do
-      { [__MODULE__.Record],
-        (target = Module.concat(__MODULE__, :erlang.element(1, xA))
-        try do
-          target.unquote(name)(unquote_splicing(args))
-        catch
-          :error, :undef, [[{ ^target, name, args, _ }|_]|_] when
-              name == unquote(name) and length(args) == unquote(arity) ->
-            apply unquote(fallback), name, [unquote_splicing(args)]
-        end) }
-    end
-  end
-
-  defmacro def(expression) do
-    case expression do
-      { _, _, args } when args == [] or is_atom(args) ->
-        raise ArgumentError, message: "protocol functions expect at least one argument"
-      { name, _, args } when is_atom(name) and is_list(args) ->
-        :ok
-      _ ->
-        raise ArgumentError, message: "invalid args for defprotocol"
-    end
-
-    arity = length(args)
-
-    type_args = lc _ inlist :lists.seq(2, arity), do: quote(do: term)
-    type_args = [quote(do: t) | type_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))
-
-      { args, body } = Protocol.DSL.args_and_body(__MODULE__, name, arity)
-      Kernel.def unquote(name), args, [], do: body
-
-      # Convert the spec to callback if possible,
-      # otherwise generate a dummy callback
-      Protocol.DSL.callback_from_spec(__MODULE__, name, arity) ||
-        @callback unquote(name)(unquote_splicing(type_args)) :: term
-    end
-  end
-end
@@ -1,70 +0,0 @@
-defrecord Range, [:first, :last] do
-  @moduledoc """
-  Defines a Range.
-  """
-end
-
-defprotocol Range.Iterator do
-  def reduce(first, range, acc, fun)
-
-  @doc """
-  Count how many items are in the range.
-  """
-  def count(first, range)
-end
-
-defimpl Enumerable, for: Range do
-  def reduce(Range[first: first] = range, acc, fun) do
-    Range.Iterator.reduce(first, range, acc, fun)
-  end
-  def member?(Range[first: first, last: last], value) do
-    value in first..last
-  end
-
-  def count(Range[first: first] = range) do
-    Range.Iterator.count(first, range)
-  end
-end
-
-defimpl Range.Iterator, for: Number do
-  def reduce(first, Range[last: last], acc, fun) when is_integer(first) and is_integer(last) do
-    reducer = if last >= first do
-      fn(acc, fun) -> do_reducer_up(first, last, acc, fun) end
-    else
-      fn(acc, fun) -> do_reducer_down(first, last, acc, fun) end
-    end
-    Enumerable.Function.reduce(reducer, acc, fun)
-  end
-
-  defp do_reducer_up(counter, last, acc, _fun) when counter > last do
-    acc
-  end
-
-  defp do_reducer_up(counter, last, acc, fun) do
-    do_reducer_up(counter + 1, last, fun.(counter, acc), fun)
-  end
-
-  defp do_reducer_down(counter, last, acc, _fun) when counter < last do
-    acc
-  end
-
-  defp do_reducer_down(counter, last, acc, fun) do
-    do_reducer_down(counter - 1, last, fun.(counter, acc), fun)
-  end
-
-  def count(first, Range[last: last]) when is_integer(first) and is_integer(last) and last >= first do
-    last - first + 1
-  end
-
-  def count(first, Range[last: last]) when is_integer(first) and is_integer(last) do
-    first - last + 1
-  end
-end
-
-defimpl Binary.Inspect, for: Range do
-  import Kernel, except: [inspect: 2]
-
-  def inspect(Range[first: first, last: last], opts) do
-    Kernel.inspect(first, opts) <> ".." <> Kernel.inspect(last, opts)
-  end
-end
@@ -1,806 +0,0 @@
-defmodule Record do
-  @moduledoc %B"""
-  Functions to define Elixir records
-
-  A record is a tagged tuple which contains one or more elements and the first
-  element is a module. One creates a record by calling `defrecord` or
-  `defrecordp` which are documented in `Kernel`.
-
-  ## Examples
-
-      defrecord FileInfo, atime: nil, accesses: 0
-
-  The line above will define a module named `FileInfo` which
-  contains a function named `new` that returns a new record
-  and other functions to read and set the values in the
-  record:
-
-      file_info = FileInfo.new(atime: now())
-      file_info.atime         #=> Returns the value of atime
-      file_info.atime(now())  #=> Updates the value of atime
-
-      # Update multiple attributes at once:
-      file_info.update(atime: now(), accesses: 1)
-
-      # Obtain the keywords representation of a record:
-      file_info.to_keywords   #=> [accesses: 1, atime: {1370,7171,911705}]
-
-
-  A record is simply a tuple where the first element is the record
-  module name. We can get the record raw representation as follow:
-
-      inspect FileInfo.new, raw: true
-      #=> { FileInfo, nil, nil }
-
-  Besides defining readers and writers for each attribute, Elixir also
-  defines an `update_#{attribute}` function to update the value. Such
-  functions expect a function as argument that receives the current
-  value and must return the new one. For example, every time the file
-  is accessed, the accesses counter can be incremented with:
-
-      file_info.update_accesses(fn(old) -> old + 1 end)
-
-  Which can be also written as:
-
-      file_info.update_accesses(&1 + 1)
-
-  ## Access syntax
-
-  Records in Elixir can be expanded at compilation time to provide
-  pattern matching and faster operations. For example, the clause
-  below will only match if a `FileInfo` is given and the number of
-  accesses is zero:
-
-      def enforce_no_access(FileInfo[accesses: 0]), do: :ok
-
-  The clause above will expand to:
-
-      def enforce_no_access({ FileInfo, _, 0 }), do: :ok
-
-  The downside of using such syntax is that, every time the record
-  changes, your code now needs to be recompiled (which is usually
-  not a concern since Elixir build tools by default recompiles the
-  whole project whenever there is a change).
-
-  Finally, keep in mind that Elixir triggers some optimizations whenever
-  the access syntax is used. For example:
-
-      def no_access?(FileInfo[] = file_info) do
-        file_info.accesses == 0
-      end
-
-  Is translated to:
-
-      def no_access?({ FileInfo, _, _ } = file_info) do
-        elem(file_info, 1) == 0
-      end
-
-  Which provides faster get and set times for record operations.
-
-  ## Runtime introspection
-
-  At runtime, developers can use `__record__` to get information
-  about the given record:
-
-      FileInfo.__record__(:name)
-      #=> FileInfo
-
-      FileInfo.__record__(:fields)
-      #=> [atime: nil, accesses: 0]
-
-  In order to quickly access the index of a field, one can use
-  the `__index__` function:
-
-      FileInfo.__index__(:atime)
-      #=> 0
-
-      FileInfo.__index__(:unknown)
-      #=> nil
-
-  ## Compile-time introspection
-
-  At the compile time, one can access following information about the record
-  from within the record module:
-
-  * `@record_fields` — a keyword list of record fields with defaults
-  * `@record_types` — a keyword list of record fields with types
-
-       defrecord Foo, bar: nil do
-         record_type bar: nil | integer
-         IO.inspect @record_fields
-         IO.inspect @record_types
-       end
-
-  prints out
-
-       [bar: nil]
-       [bar: {:|,[line: ...],[nil,{:integer,[line: ...],nil}]}]
-
-  where the last line is a quoted representation of
-
-       [bar: nil | integer]
-
-  ## Documentation
-
-  By default records are not documented and have `@moduledoc` set to false.
-
-  ## Types
-
-  Every record defines a type named `t` that can be accessed in typespecs.
-  For example, assuming the `Config` record defined above, it could be used
-  in typespecs as follow:
-
-      @spec handle_config(Config.t) :: boolean()
-
-  Inside the record definition, a developer can define his own types too:
-
-      defrecord Config, counter: 0, failures: [] do
-        @type kind :: term
-        record_type counter: integer, failures: [kind]
-      end
-
-  When defining a type, all the fields not mentioned in the type are
-  assumed to have type `term`.
-
-  ## Importing records
-
-  It is also possible to import a public record (a record, defined using
-  `defrecord`) as a set of private macros (as if it was defined using `defrecordp`):
-
-      Record.import Config, as: :config
-
-  See `Record.import/2` and `defrecordp/2` documentation for more information
-  """
-
-  @doc """
-  Extract record information from an Erlang file and
-  return the fields as a list of tuples.
-
-  ## Examples
-
-      defrecord FileInfo, Record.extract(:file_info, from_lib: "kernel/include/file.hrl")
-
-  """
-  def extract(name, opts) do
-    Record.Extractor.retrieve(name, opts)
-  end
-
-  @doc """
-  Main entry point for records definition. It defines a module
-  with the given `name` and the fields specified in `values`.
-  This is invoked directly by `Kernel.defrecord`, so check it
-  for more information and documentation.
-  """
-  def defrecord(name, values, opts) do
-    block = Keyword.get(opts, :do, nil)
-
-    quote do
-      unquoted_values = unquote(values)
-
-      defmodule unquote(name) do
-        @moduledoc false
-        import Elixir.Record.DSL
-
-        @record_fields []
-        @record_types  []
-
-        # Reassign values to inner scope to
-        # avoid conflicts in nested records
-        values = unquoted_values
-
-        Elixir.Record.deffunctions(values, __ENV__)
-        value = unquote(block)
-        Elixir.Record.deftypes(values, @record_types, __ENV__)
-        value
-      end
-    end
-  end
-
-  @doc """
-  Import public record definition as a set of private macros (as defined by defrecordp/2)
-
-  ## Usage
-
-     Record.import Record.Module, as: macro_name
-
-  ## Example
-
-     defmodule Test do
-       Record.import File.Stat, as: :file_stat
-
-       def size(file_stat(size: size)), do: size
-     end
-
-  """
-  defmacro import(module, as: name) do
-    quote do
-      Record.defmacros(unquote(name), unquote(module).__record__(:fields), __ENV__, unquote(module))
-    end
-  end
-
-  @doc """
-  Main entry point for private records definition. It defines
-  a set of macros with the given `name` and the fields specified
-  in `values`. This is invoked directly by `Kernel.defrecordp`,
-  so check it for more information and documentation.
-  """
-  def defrecordp(name, fields) do
-    quote do
-      Record.defmacros(unquote(name), unquote(fields), __ENV__)
-    end
-  end
-
-  @doc """
-  Defines record functions skipping the module definition.
-  This is called directly by `defrecord`. It expects the record
-  values, a set of options and the module environment.
-
-  ## Examples
-
-      defmodule CustomRecord do
-        Record.deffunctions [:name, :age], __ENV__
-        Record.deftypes [:name, :age], [name: :binary, age: :integer], __ENV__
-      end
-
-  """
-  def deffunctions(values, env) do
-    values  = lc value inlist values, do: convert_value(value)
-    escaped = Macro.escape(values)
-
-    contents = [
-      reflection(escaped),
-      initializer(escaped),
-      indexes(escaped),
-      conversions(values),
-      record_optimizable(),
-      updater(values),
-      accessors(values, 1),
-      switch_recorder()
-    ]
-
-    contents = [quote(do: @record_fields unquote(escaped))|contents]
-
-    # Special case for bootstraping purposes
-    if env == Macro.Env do
-      Module.eval_quoted(env, contents, [], [])
-    else
-      Module.eval_quoted(env.module, contents, [], env.location)
-    end
-  end
-
-  @doc """
-  Defines types and specs for the record.
-  """
-  def deftypes(values, types, env) do
-    types  = types || []
-    values = lc value inlist values do
-      { name, default } = convert_value(value)
-      { name, default, find_spec(types, name) }
-    end
-
-    contents = [
-      core_specs(values),
-      accessor_specs(values, 1, [])
-    ]
-
-    if env == Macro.Env do
-      Module.eval_quoted(env, contents, [], [])
-    else
-      Module.eval_quoted(env.module, contents, [], env.location)
-    end
-  end
-
-  @doc """
-  Defines macros for manipulating records. This is called
-  directly by `defrecordp`. It expects the macro name, the
-  record values and the environment.
-
-  ## Examples
-
-      defmodule CustomRecord do
-        Record.defmacros :user, [:name, :age], __ENV__
-      end
-
-  """
-  def defmacros(name, values, env, tag // nil) do
-    escaped = lc value inlist values do
-      { key, value } = convert_value(value)
-      { key, Macro.escape(value) }
-    end
-
-    contents = quote do
-      defmacrop unquote(name)() do
-        Record.access(unquote(tag) || __MODULE__, unquote(escaped), [], __CALLER__)
-      end
-
-      defmacrop unquote(name)(record) when is_tuple(record) do
-        Record.to_keywords(unquote(tag) || __MODULE__, unquote(escaped), record)
-      end
-
-      defmacrop unquote(name)(args) do
-        Record.access(unquote(tag) || __MODULE__, unquote(escaped), args, __CALLER__)
-      end
-
-      defmacrop unquote(name)(record, key) when is_atom(key) do
-        Record.get(unquote(tag) || __MODULE__, unquote(escaped), record, key)
-      end
-
-      defmacrop unquote(name)(record, args) do
-        Record.dispatch(unquote(tag) || __MODULE__, unquote(escaped), record, args, __CALLER__)
-      end
-    end
-
-    Module.eval_quoted(env.module, contents, [], env.location)
-  end
-
-  ## Callbacks
-
-  # Store all optimizable fields in the record as well
-  @doc false
-  defmacro __before_compile__(_) do
-    quote do
-      def __record__(:optimizable), do: @record_optimizable
-    end
-  end
-
-  # Store fields that can be optimized and that cannot be
-  # optimized as they are overriden
-  @doc false
-  def __on_definition__(env, kind, name, args, _guards, _body) do
-    tuple     = { name, length(args) }
-    module    = env.module
-    functions = Module.get_attribute(module, :record_optimizable)
-
-    functions =
-      if kind in [:def] and Module.get_attribute(module, :record_optimized) do
-        [tuple|functions]
-      else
-        List.delete(functions, tuple)
-      end
-
-    Module.put_attribute(module, :record_optimizable, functions)
-  end
-
-  # Implements the access macro used by records.
-  # It returns a quoted expression that defines
-  # a record or a match in case the record is
-  # inside a match.
-  @doc false
-  def access(atom, fields, keyword, caller) do
-    unless is_keyword(keyword) do
-      raise "expected contents inside brackets to be a Keyword"
-    end
-
-    in_match = caller.in_match?
-
-    has_underscore_value = Keyword.has_key?(keyword, :_)
-    underscore_value     = Keyword.get(keyword, :_, { :_, [], nil })
-    keyword              = Keyword.delete keyword, :_
-
-    iterator = fn({field, default}, each_keyword) ->
-      new_fields =
-        case Keyword.has_key?(each_keyword, field) do
-          true  -> Keyword.get(each_keyword, field)
-          false ->
-            case in_match or has_underscore_value do
-              true  -> underscore_value
-              false -> Macro.escape(default)
-            end
-        end
-
-      { new_fields, Keyword.delete(each_keyword, field) }
-    end
-
-    { match, remaining } = :lists.mapfoldl(iterator, keyword, fields)
-
-    case remaining do
-      [] ->
-        quote do: { unquote_splicing([atom|match]) }
-      _  ->
-        keys = lc { key, _ } inlist remaining, do: key
-        raise "record #{inspect atom} does not have the keys: #{inspect keys}"
-    end
-  end
-
-  # Dispatch the call to either update or to_list depending on the args given.
-  @doc false
-  def dispatch(atom, fields, record, args, caller) do
-    if is_keyword(args) do
-      update(atom, fields, record, args, caller)
-    else
-      to_list(atom, fields, record, args)
-    end
-  end
-
-  # Implements the update macro defined by defmacros.
-  # It returns a quoted expression that represents
-  # the access given by the keywords.
-  @doc false
-  defp update(atom, fields, var, keyword, caller) do
-    unless is_keyword(keyword) do
-      raise "expected contents inside brackets to be a Keyword"
-    end
-
-    if caller.in_match? do
-      raise "cannot invoke update style macro inside match context"
-    end
-
-    Enum.reduce keyword, var, fn({ key, value }, acc) ->
-      index = find_index(fields, key, 0)
-      if index do
-        quote do
-          :erlang.setelement(unquote(index + 2), unquote(acc), unquote(value))
-        end
-      else
-        raise "record #{inspect atom} does not have the key: #{inspect key}"
-      end
-    end
-  end
-
-  # Implements the get macro defined by defmacros.
-  # It returns a quoted expression that represents
-  # getting the value of a given field.
-  @doc false
-  def get(atom, fields, var, key) do
-    index = find_index(fields, key, 0)
-    if index do
-      quote do
-        :erlang.element(unquote(index + 2), unquote(var))
-      end
-    else
-      raise "record #{inspect atom} does not have the key: #{inspect key}"
-    end
-  end
-
-  # Implements to_keywords macro defined by defmacros.
-  # It returns a quoted expression that represents
-  # converting record to keywords list.
-  @doc false
-  def to_keywords(_atom, fields, record) do
-    Enum.map fields,
-      fn { key, _default } ->
-        index = find_index(fields, key, 0)
-        quote do
-          { unquote(key), :erlang.element(unquote(index + 2), unquote(record)) }
-        end
-      end
-  end
-
-  # Implements to_list macro defined by defmacros.
-  # It returns a quoted expression that represents
-  # extracting given fields from record.
-  @doc false
-  defp to_list(atom, fields, record, keys) do
-    Enum.map keys,
-      fn(key) ->
-        index = find_index(fields, key, 0)
-        if index do
-          quote do: :erlang.element(unquote(index + 2), unquote(record))
-        else
-          raise "record #{inspect atom} does not have the key: #{inspect key}"
-        end
-      end
-  end
-
-  ## Function generation
-
-  # Define __record__/1 and __record__/2 as reflection functions
-  # that returns the record names and fields.
-  #
-  # Note that fields are *not* keywords. They are in the same
-  # order as given as parameter and reflects the order of the
-  # fields in the tuple.
-  #
-  # ## Examples
-  #
-  #     defrecord FileInfo, atime: nil, mtime: nil
-  #
-  #     FileInfo.__record__(:name)   #=> FileInfo
-  #     FileInfo.__record__(:fields) #=> [atime: nil, mtime: nil]
-  #
-  defp reflection(values) do
-    quote do
-      @doc false
-      def __record__(kind, _),      do: __record__(kind)
-
-      @doc false
-      def __record__(:name),        do: __MODULE__
-      def __record__(:fields),      do: unquote(values)
-    end
-  end
-
-  # Define initializers methods. For a declaration like:
-  #
-  #     defrecord FileInfo, atime: nil, mtime: nil
-  #
-  # It will define three methods:
-  #
-  #     def new() do
-  #       new([])
-  #     end
-  #
-  #     def new([]) do
-  #       { FileInfo, nil, nil }
-  #     end
-  #
-  #     def new(opts) do
-  #       { FileInfo, Keyword.get(opts, :atime), Keyword.get(opts, :mtime) }
-  #     end
-  #
-  defp initializer(values) do
-    defaults = lc { _, value } inlist values, do: value
-
-    # For each value, define a piece of code that will receive
-    # an ordered dict of options (opts) and it will try to fetch
-    # the given key from the ordered dict, falling back to the
-    # default value if one does not exist.
-    selective = lc { k, v } inlist values do
-      quote do: Keyword.get(opts, unquote(k), unquote(v))
-    end
-
-    quote do
-      @doc false
-      def new(), do: new([])
-
-      @doc false
-      def new([]), do: { __MODULE__, unquote_splicing(defaults) }
-      def new(opts) when is_list(opts), do: { __MODULE__, unquote_splicing(selective) }
-      def new(tuple) when is_tuple(tuple), do: :erlang.setelement(1, tuple, __MODULE__)
-    end
-  end
-
-  # Define method to get index of a given key.
-  #
-  # Useful if you need to know position of the key for such applications as:
-  #  - ets
-  #  - mnesia
-  #
-  # For a declaration like:
-  #
-  #     defrecord FileInfo, atime: nil, mtime: nil
-  #
-  # It will define following method:
-  #
-  #     def __index__(:atime), do: 2
-  #     def __index__(:mtime), do: 3
-  #     def __index__(_), do: nil
-  #
-  defp indexes(values) do
-    quoted = lc { k, _ } inlist values do
-      index = find_index(values, k, 0)
-      quote do
-        @doc false
-        def __index__(unquote(k)), do: unquote(index + 1)
-      end
-    end
-    quote do
-      unquote(quoted)
-
-      @doc false
-      def __index__(_), do: nil
-
-      @doc false
-      def __index__(key, _), do: __index__(key)
-    end
-  end
-
-  # Define converters method(s). For a declaration like:
-  #
-  #     defrecord FileInfo, atime: nil, mtime: nil
-  #
-  # It will define one method, to_keywords, which will return a Keyword
-  #
-  #    [atime: nil, mtime: nil]
-  #
-  defp conversions(values) do
-    sorted = lc { k, _ } inlist values do
-      index = find_index(values, k, 0)
-      { k, quote(do: :erlang.element(unquote(index + 2), record)) }
-    end
-
-    quote do
-      @doc false
-      def to_keywords(record) do
-        unquote(:orddict.from_list(sorted))
-      end
-    end
-  end
-
-  # Implement accessors. For a declaration like:
-  #
-  #     defrecord FileInfo, atime: nil, mtime: nil
-  #
-  # It will define four methods:
-  #
-  #     def atime(record) do
-  #       elem(record, 1)
-  #     end
-  #
-  #     def mtime(record) do
-  #       elem(record, 2)
-  #     end
-  #
-  #     def atime(value, record) do
-  #       set_elem(record, 1, value)
-  #     end
-  #
-  #     def mtime(record) do
-  #       set_elem(record, 2, value)
-  #     end
-  #
-  #     def atime(callback, record) do
-  #       set_elem(record, 1, callback.(elem(record, 1)))
-  #     end
-  #
-  #     def mtime(callback, record) do
-  #       set_elem(record, 2, callback.(elem(record, 2)))
-  #     end
-  #
-  defp accessors([{ :__exception__, _ }|t], 1) do
-    accessors(t, 2)
-  end
-
-  defp accessors([{ key, _default }|t], i) do
-    update = binary_to_atom "update_" <> atom_to_binary(key)
-
-    contents = quote do
-      @doc false
-      def unquote(key)(record) do
-        :erlang.element(unquote(i + 1), record)
-      end
-
-      @doc false
-      def unquote(key)(value, record) do
-        :erlang.setelement(unquote(i + 1), record, value)
-      end
-
-      @doc false
-      def unquote(update)(function, record) do
-        :erlang.setelement(unquote(i + 1), record,
-          function.(:erlang.element(unquote(i + 1), record)))
-      end
-    end
-
-    [contents|accessors(t, i + 1)]
-  end
-
-  defp accessors([], _i) do
-    []
-  end
-
-  # Define an updater method that receives a
-  # keyword list and updates the record.
-  defp updater(values) do
-    fields =
-      lc {key, _default} inlist values do
-        index = find_index(values, key, 1)
-        quote do
-          Keyword.get(keywords, unquote(key), elem(record, unquote(index)))
-        end
-      end
-
-    contents = quote do: { __MODULE__, unquote_splicing(fields) }
-
-    quote do
-      @doc false
-      def update([], record) do
-        record
-      end
-
-      def update(keywords, record) do
-        unquote(contents)
-      end
-    end
-  end
-
-  defp record_optimizable do
-    quote do
-      @record_optimized true
-      @record_optimizable []
-      @before_compile { unquote(__MODULE__), :__before_compile__ }
-      @on_definition { unquote(__MODULE__), :__on_definition__ }
-    end
-  end
-
-  defp switch_recorder do
-    quote do: @record_optimized false
-  end
-
-  ## Types/specs generation
-
-  defp core_specs(values) do
-    types   = lc { _, _, spec } inlist values, do: spec
-    options = if values == [], do: [], else: [options_specs(values)]
-
-    quote do
-      unless Kernel.Typespec.defines_type?(__MODULE__, :t, 0) do
-        @type t :: { __MODULE__, unquote_splicing(types) }
-      end
-
-      unless Kernel.Typespec.defines_type?(__MODULE__, :options, 0) do
-        @type options :: unquote(options)
-      end
-
-      @spec new :: t
-      @spec new(options | tuple) :: t
-      @spec to_keywords(t) :: options
-      @spec update(options, t) :: t
-      @spec __record__(:name) :: atom
-      @spec __record__(:fields) :: [{atom,any}]
-      @spec __index__(atom) :: non_neg_integer | nil
-    end
-  end
-
-  defp options_specs([{ k, _, v }|t]) do
-    :lists.foldl fn { k, _, v }, acc ->
-      { :|, [], [{ k, v }, acc] }
-    end, { k, v }, t
-  end
-
-  defp accessor_specs([{ :__exception__, _, _ }|t], 1, acc) do
-    accessor_specs(t, 2, acc)
-  end
-
-  defp accessor_specs([{ key, _default, spec }|t], i, acc) do
-    update = binary_to_atom "update_" <> atom_to_binary(key)
-
-    contents = quote do
-      @spec unquote(key)(t) :: unquote(spec)
-      @spec unquote(key)(unquote(spec), t) :: t
-      @spec unquote(update)((unquote(spec) -> unquote(spec)), t) :: t
-    end
-
-    accessor_specs(t, i + 1, [contents | acc])
-  end
-
-  defp accessor_specs([], _i, acc), do: acc
-
-  ## Helpers
-
-  defp is_keyword(list) when is_list(list), do: :lists.all(is_keyword_tuple(&1), list)
-  defp is_keyword(_), do: false
-
-  defp is_keyword_tuple({ x, _ }) when is_atom(x), do: true
-  defp is_keyword_tuple(_), do: false
-
-  defp convert_value(atom) when is_atom(atom), do: { atom, nil }
-
-  defp convert_value({ atom, other }) when is_atom(atom) and is_function(other), do:
-    raise ArgumentError, message: "record field default value #{inspect atom} cannot be a function"
-
-  defp convert_value({ atom, other }) when is_atom(atom) and (is_reference(other) or is_pid(other) or is_port(other)), do:
-    raise ArgumentError, message: "record field default value #{inspect atom} cannot be a reference, pid or port"
-
-  defp convert_value({ atom, _ } = tuple) when is_atom(atom), do: tuple
-
-  defp convert_value({ field, _ }), do:
-    raise ArgumentError, message: "record field name has to be an atom, got #{inspect field}"
-
-  defp find_index([{ k, _ }|_], k, i), do: i
-  defp find_index([{ _, _ }|t], k, i), do: find_index(t, k, i + 1)
-  defp find_index([], _k, _i), do: nil
-
-  defp find_spec(types, name) do
-    matches = lc { k, v } inlist types, name == k, do: v
-    case matches do
-      [h|_] -> h
-      _     -> quote do: term
-    end
-  end
-end
-
-defmodule Record.DSL do
-  @moduledoc false
-
-  @doc """
-  Defines the type for each field in the record.
-  Expects a keyword list.
-  """
-  defmacro record_type(opts) when is_list(opts) do
-    escaped = lc { k, v } inlist opts, do: { k, Macro.escape(v) }
-
-    quote do
-      @record_types Keyword.merge(@record_types || [], unquote(escaped))
-    end
-  end
-end
@@ -1,79 +0,0 @@
-defmodule Record.Extractor do
-  @moduledoc false
-
-  # Retrieve a record definition from an Erlang file using
-  # the same lookup as the *include* attribute from Erlang modules.
-  def retrieve(name, from: string) do
-    file = to_char_list(string)
-
-    case :code.where_is_file(file) do
-      :non_existing -> realfile = file
-      realfile -> nil
-    end
-
-    retrieve_record(name, realfile)
-  end
-
-  # Retrieve a record definition from an Erlang file using
-  # the same lookup as the *include_lib* attribute from Erlang modules.
-  def retrieve(name, from_lib: file) do
-    [app|path] = :filename.split(to_char_list(file))
-
-    case :code.lib_dir(to_char_list(app)) do
-      { :error, _ } ->
-        raise ArgumentError, "lib file #{to_binary(file)} could not be found"
-      libpath ->
-        retrieve_record name, :filename.join([libpath|path])
-    end
-  end
-
-  # Retrieve the record with the given name from the given file
-  defp retrieve_record(name, file) do
-    records = retrieve_from_file(file)
-    if record = List.keyfind(records, name, 0) do
-      parse_record(record)
-    else
-      raise ArgumentError, "no record #{name} found at #{to_binary(file)}"
-    end
-  end
-
-  # Parse the given file and retrieve all existent records.
-  defp retrieve_from_file(file) do
-    lc { :attribute, _, :record, record } inlist read_file(file), do: record
-  end
-
-  # Read a file and return its abstract syntax form that also
-  # includes record and other preprocessor modules. This is done
-  # by using Erlang's epp_dodger.
-  defp read_file(file) do
-    case :epp_dodger.quick_parse_file(file) do
-      { :ok, form } ->
-        form
-      other ->
-        raise "error parsing file #{to_binary(file)}, got: #{inspect(other)}"
-    end
-  end
-
-  # Parse a tuple with name and fields and returns a
-  # list of tuples where the first element is the field
-  # and the second is its default value.
-  defp parse_record({ _name, fields }) do
-    cons = List.foldr fields, { nil, 0 }, fn f, acc ->
-      { :cons, 0, parse_field(f), acc }
-    end
-    { :value, list, _ } = :erl_eval.expr(cons, [])
-    list
-  end
-
-  defp parse_field({ :typed_record_field, record_field, _type }) do
-    parse_field(record_field)
-  end
-
-  defp parse_field({ :record_field, _, key }) do
-    { :tuple, 0, [key, {:atom, 0, :undefined}] }
-  end
-
-  defp parse_field({ :record_field, _, key, value }) do
-    { :tuple, 0, [key, value] }
-  end
-end
@@ -1,354 +0,0 @@
-defmodule Regex do
-  @moduledoc %B"""
-  Regular expressions for Elixir built on top of the re module
-  in the Erlang Standard Library. More information can be found
-  on re documentation: http://www.erlang.org/doc/man/re.html
-
-  Regular expressions in Elixir can be created using Regex.compile!
-  or using the special form with `%r`:
-
-      # A simple regular expressions that matches foo anywhere in the string
-      %r/foo/
-
-      # A regular expression with case insensitive options and handle unicode chars
-      %r/foo/iu
-
-  The re module provides several options, the one available in Elixir, followed by
-  their shortcut in parenthesis, are:
-
-  * unicode (u) - enable unicode specific patterns like \p
-  * caseless (i) - add case insensitivity
-  * dotall (s) - causes dot to match newlines and also set newline to anycrlf.
-    The new line setting can be overwritten by setting `(*CR)` or `(*LF)` or
-    `(*CRLF)` or `(*ANY)` according to re documentation
-  * multiline (m) - causes `^` and `$` to mark the beginning and end of each line.
-    You need to use `\A` and `\z` to match the end or beginning of the string
-  * extended (x) - whitespace characters are ignored except when escaped and
-    allow `#` to delimit comments
-  * firstline (f) - forces the unanchored pattern to match before or at the first
-    newline, though the matched text may continue over the newline
-  * ungreedy (r) - invert the "greediness" of the regexp
-  * groups (g) - compile with info about groups available
-
-  The options not available are:
-
-  * anchored - not available, use `^` or `\A` instead
-  * dollar_endonly - not available, use `\z` instead
-  * no_auto_capture - not available, use `?:` instead
-  * newline - not available, use `(*CR)` or `(*LF)` or `(*CRLF)` or `(*ANYCRLF)`
-    or `(*ANY)` at the beginning of the regexp according to the re documentation
-
-  Most of the functions in this module accept either a binary or a char list
-  as subject. The result is based on the argument (a binary will return
-  a binary, a char list will return a char list).
-  """
-
-  defrecordp :regex, [:re_pattern, :source, :options, :groups]
-  @type t :: { Regex, term, term, term, term }
-
-  defexception CompileError, message: "regex could not be compiled"
-
-  @doc """
-  Compiles the regular expression according to the given options.
-
-  It returns `{ :ok, regex }` in case of success,
-  `{ :error, reason }` otherwise.
-  """
-  def compile(source, options // "") when is_binary(source) do
-    options = to_binary(options)
-    opts    = translate_options(options)
-    re_opts = opts -- [:groups]
-    groups  = if opts != re_opts, do: parse_groups(source)
-
-    case :re.compile(source, re_opts) do
-      { :ok, re_pattern } ->
-        { :ok, regex(re_pattern: re_pattern, source: source, options: options, groups: groups) }
-      error ->
-        error
-    end
-  end
-
-  @doc """
-  Compiles the regular expression according to the given options.
-  Fails with `Regex.CompileError` if the regex cannot be compiled.
-  """
-  def compile!(source, options // "") do
-    case compile(source, options) do
-      { :ok, regex } -> regex
-      { :error, { reason, at } } -> raise Regex.CompileError, message: "#{reason} at position #{at}"
-    end
-  end
-
-  @doc false
-  def index(regex(re_pattern: compiled), string) do
-    IO.puts "Regex.index(re, string) is deprecated. Please use " <>
-      "Regex.run(re, string, return: :index) instead."
-    Exception.print_stacktrace
-
-    case :re.run(string, compiled, [{ :capture, :first, :index }]) do
-      :nomatch -> nil
-      { :match, [{index,_}] } -> index
-    end
-  end
-
-  @doc """
-  Returns a boolean if there was a match or not.
-
-  ## Examples
-
-      iex> Regex.match?(%r/foo/, "foo")
-      true
-      iex> Regex.match?(%r/foo/, "bar")
-      false
-
-  """
-  def match?(regex(re_pattern: compiled), string) do
-    :re.run(string, compiled, [{ :capture, :none }]) == :match
-  end
-
-  @doc """
-  Runs the regular expression against the given string.
-  It returns a list with all matches, nil if no match ocurred, or []
-  if it matched, /g was specified, but nothing was captured.
-
-  ## Examples
-
-      iex> Regex.run(%r/c(d)/, "abcd")
-      ["cd", "d"]
-      iex> Regex.run(%r/e/, "abcd")
-      nil
-      iex> Regex.run(%r/c(d)/, "abcd", return: :index)
-      [{2,2},{3,1}]
-
-  """
-  def run(regex, string, options // [])
-
-  def run(regex(re_pattern: compiled, groups: groups), string, options) do
-    return = Keyword.get(options, :return, return_for(string))
-
-    captures =
-      case Keyword.get(options, :capture, :all) do
-        :groups -> groups || raise ArgumentError, message: "regex was not compiled with g"
-        others  -> others
-      end
-
-    case :re.run(string, compiled, [{ :capture, captures, return }]) do
-      :nomatch -> nil
-      :match   -> []
-      { :match, results } -> results
-    end
-  end
-
-  @doc """
-  Returns the given captures as a list of tuples.
-  Requires the regex to be compiled with the groups option.
-
-  ## Examples
-
-      iex> Regex.captures(%r/c(?<foo>d)/g, "abcd")
-      [foo: "d"]
-
-  """
-  def captures(regex(groups: groups) = regex, string, options // []) do
-    unless captures = Keyword.get(options, :capture) do
-      captures = if groups do
-        Enum.sort(groups)
-      else
-        raise ArgumentError, message: "regex was not compiled with g"
-      end
-      options  = Keyword.put(options, :capture, captures)
-    end
-    results = run(regex, string, options)
-    if results, do: Enum.zip captures, results
-  end
-
-  @doc """
-  Returns the underlying `re_pattern` in the regular expression.
-  """
-  def re_pattern(regex(re_pattern: compiled)) do
-    compiled
-  end
-
-  @doc """
-  Returns the regex source as binary.
-
-  ## Examples
-
-      iex> Regex.source(%r(foo))
-      "foo"
-
-  """
-  def source(regex(source: source)) do
-    source
-  end
-
-  @doc """
-  Returns the regex options as a string.
-
-  ## Examples
-
-      iex> Regex.opts(%r(foo)m)
-      "m"
-
-  """
-  def opts(regex(options: options)) do
-    options
-  end
-
-  @doc """
-  Returns list of named groups in regex.
-
-  ## Examples
-
-      iex> Regex.groups(%r/(?<foo>foo)/g)
-      [:foo]
-
-  """
-  def groups(regex(groups: groups)) do
-    groups
-  end
-
-  @doc """
-  Same as run, but scans the target several times collecting all matches of
-  the regular expression. A list is returned with each match. If the item in
-  the list is a binary, it means there were no captures. If the item is another
-  list, each element in this secondary list is a capture.
-
-  ## Examples
-
-      iex> Regex.scan(%r/c(d|e)/, "abcd abce")
-      [["d"], ["e"]]
-      iex> Regex.scan(%r/c(?:d|e)/, "abcd abce")
-      ["cd", "ce"]
-      iex> Regex.scan(%r/e/, "abcd")
-      []
-
-  """
-  def scan(regex, string, options // [])
-
-  def scan(regex(re_pattern: compiled), string, options) do
-    return  = Keyword.get(options, :return, return_for(string))
-    options = [{ :capture, :all, return }, :global]
-    case :re.run(string, compiled, options) do
-      :nomatch -> []
-      { :match, results } -> flatten_result(results)
-    end
-  end
-
-  @doc """
-  Split the given target in the number of parts specified.
-  If no ammount of parts is given, it defaults to :infinity.
-  """
-
-  def split(regex, string, options // [])
-
-  def split(regex(re_pattern: compiled), string, options) do
-    parts =
-      cond do
-        Keyword.get(options, :global) == false -> 2
-        p = Keyword.get(options, :parts)       -> p
-        true                                   -> :infinity
-      end
-
-    return = Keyword.get(options, :return, return_for(string))
-    opts   = [return: return, parts: parts]
-    :re.split(string, compiled, opts)
-  end
-
-  @doc %B"""
-  Receives a regex, a binary and a replacement and returns a new
-  binary where the all matches are replaced by replacement.
-
-  Inside the replacement, you can either give "&" to access the
-  whole regular expression or \N, where N is in integer to access
-  a specific matching parens. You can also set global to false
-  if you want to replace just the first occurrence.
-
-  ## Examples
-
-      iex> Regex.replace(%r/d/, "abc", "d")
-      "abc"
-      iex> Regex.replace(%r/b/, "abc", "d")
-      "adc"
-      iex> Regex.replace(%r/b/, "abc", "[&]")
-      "a[b]c"
-      iex> Regex.replace(%r/b/, "abc", "[\\&]")
-      "a[&]c"
-      iex> Regex.replace(%r/(b)/, "abc", "[\\1]")
-      "a[b]c"
-
-  """
-  def replace(regex(re_pattern: compiled), string, replacement, options // []) do
-    opts   = if Keyword.get(options, :global) != false, do: [:global], else: []
-    return = Keyword.get(options, :return, return_for(string))
-    opts   = [{ :return, return }|opts]
-    :re.replace(string, compiled, replacement, opts)
-  end
-
-  { :ok, pattern } = :re.compile(%B"[.^$*+?()[{\\\|\s#]", [:unicode])
-  @escape_pattern pattern
-
-  @doc %B"""
-  Escapes a string to be literally matched in a regex.
-
-  ## Examples
-
-      iex> Regex.escape(".")
-      "\\."
-      iex> Regex.escape("\\what if")
-      "\\\\what\\ if"
-
-  """
-  @spec escape(String.t | char_list) :: String.t | char_list
-  def escape(string) do
-    :re.replace(string, @escape_pattern, "\\\\&", [:global, { :return, return_for(string) }])
-  end
-
-  # Helpers
-
-  @doc false
-  # Unescape map function used by Macro.unescape_binary.
-  def unescape_map(?f), do: ?\f
-  def unescape_map(?n), do: ?\n
-  def unescape_map(?r), do: ?\r
-  def unescape_map(?t), do: ?\t
-  def unescape_map(?v), do: ?\v
-  def unescape_map(?a), do: ?\a
-  def unescape_map(_),  do: false
-
-  # Private Helpers
-
-  defp return_for(element) when is_binary(element), do: :binary
-  defp return_for(element) when is_list(element),   do: :list
-
-  defp translate_options(<<?u, t :: binary>>), do: [:unicode|translate_options(t)]
-  defp translate_options(<<?i, t :: binary>>), do: [:caseless|translate_options(t)]
-  defp translate_options(<<?x, t :: binary>>), do: [:extended|translate_options(t)]
-  defp translate_options(<<?f, t :: binary>>), do: [:firstline|translate_options(t)]
-  defp translate_options(<<?r, t :: binary>>), do: [:ungreedy|translate_options(t)]
-  defp translate_options(<<?s, t :: binary>>), do: [:dotall,{:newline,:anycrlf}|translate_options(t)]
-  defp translate_options(<<?m, t :: binary>>), do: [:multiline|translate_options(t)]
-  defp translate_options(<<?g, t :: binary>>), do: [:groups|translate_options(t)]
-  defp translate_options(<<>>), do: []
-
-  defp flatten_result(results) do
-    lc result inlist results do
-      case result do
-        [t] -> t
-        [_|t] -> t
-      end
-    end
-  end
-
-  { :ok, pattern } = :re.compile(%B"\(\?<(?<G>[^>]*)>")
-  @groups_pattern pattern
-
-  defp parse_groups(source) do
-    options = [:global, {:capture, ['G'], :binary}]
-    case :re.run(source, @groups_pattern, options) do
-      :nomatch -> []
-      { :match, results } ->
-        lc [group] inlist results, do: binary_to_atom(group)
-    end
-  end
-end
@@ -1,908 +0,0 @@
-defmodule String do
-  @moduledoc %B"""
-  A String in Elixir is a UTF-8 encoded binary.
-
-  ## String and binary operations
-
-  The functions in this module act according to the
-  Unicode Standard, version 6.2.0. For example,
-  `titlecase`, `downcase`, `strip` are provided by this
-  module.
-
-  Besides this module, Elixir provides more low-level
-  operations that works directly with binaries. Some
-  of those can be found in the `Kernel` module, as:
-
-  * `binary_part/2` and `binary_part/3` - retrieves part of the binary
-  * `bit_size/1` and `byte_size/1` - size related functions
-  * `is_bitstring/1` and `is_binary/1` - type checking function
-  * Plus a bunch of conversion functions, like `binary_to_atom/2`,
-    `binary_to_integer/2`, `binary_to_term/1` and their opposite
-    like `integer_to_binary/2`
-
-  Finally, [the `:binary` module](http://erlang.org/doc/man/binary.html)
-  provides a couple other functions that works on the byte level.
-
-  ## Codepoints and graphemes
-
-  As per the Unicode Standard, a codepoint is an Unicode
-  Character, which may be represented by one or more bytes.
-  For example, the character "é" is represented with two
-  bytes:
-
-      iex> string = "é"
-      ...> byte_size(string)
-      2
-
-  Furthermore, this module also presents the concept of
-  graphemes, which are multiple characters that may be
-  "perceived as a single character" by readers. For example,
-  the same "é" character written above could be represented
-  by the letter "e" followed by the accent ́:
-
-      iex> string = "\x{0065}\x{0301}"
-      ...> byte_size(string)
-      3
-
-  Although the example above is made of two characters, it is
-  perceived by users as one.
-
-  Graphemes can also be two characters that are interpreted
-  as one by some languages. For example, some languages may
-  consider "ch" as a grapheme. However, since this information
-  depends on the locale, it is not taken into account by this
-  module.
-
-  In general, the functions in this module rely on the Unicode
-  Standard, but does not contain any of the locale specific
-  behaviour.
-
-  ## Integer codepoints
-
-  Although codepoints could be represented as integers, this
-  module represents all codepoints as strings. For example:
-
-      iex> String.codepoints("josé")
-      ["j", "o", "s", "é"]
-
-  There are a couple of ways to retrieve a character integer
-  codepoint. One may use the `?` special macro:
-
-      iex> ?j
-      106
-      iex> ?é
-      233
-
-  Or also via pattern matching:
-
-      iex> << eacute :: utf8 >> = "é"
-      ...> eacute
-      233
-
-  As we have seen above, codepoints can be inserted into
-  a string by their hexadecimal code:
-
-      "jos\x{0065}\x{0301}" #=>
-      "josé"
-
-  ## Self-synchronization
-
-  The UTF-8 encoding is self-synchronizing. This means that
-  if malformed data (i.e., data that is not possible according
-  to the definition of the encoding) is encountered, only one
-  codepoint needs to be rejected.
-
-  This module relies on this behaviour to ignore such invalid
-  characters. For example, `String.length` is going to return
-  a correct result even if an invalid codepoint is fed into it.
-
-  In other words, this module expects invalid data to be detected
-  when retrieving data from the external source. For example, a
-  driver that reads strings from a database will be the one
-  responsible to check the validity of the encoding.
-  """
-
-  @type t :: binary
-  @type codepoint :: t
-  @type grapheme :: t
-
-  @doc """
-  Checks if a string is printable considering it is encoded
-  as UTF-8. Returns true if so, false otherwise.
-
-  ## Examples
-
-      iex> String.printable?("abc")
-      true
-
-  """
-  @spec printable?(t) :: boolean
-
-  def printable?(<< h :: utf8, t :: binary >>)
-      when h in ?\040..?\176
-      when h in 0xA0..0xD7FF
-      when h in 0xE000..0xFFFD
-      when h in 0x10000..0x10FFFF do
-    printable?(t)
-  end
-
-  def printable?(<<?\n, t :: binary>>), do: printable?(t)
-  def printable?(<<?\r, t :: binary>>), do: printable?(t)
-  def printable?(<<?\t, t :: binary>>), do: printable?(t)
-  def printable?(<<?\v, t :: binary>>), do: printable?(t)
-  def printable?(<<?\b, t :: binary>>), do: printable?(t)
-  def printable?(<<?\f, t :: binary>>), do: printable?(t)
-  def printable?(<<?\e, t :: binary>>), do: printable?(t)
-  def printable?(<<?\a, t :: binary>>), do: printable?(t)
-
-  def printable?(<<>>), do: true
-  def printable?(_),    do: false
-
-  @doc """
-  Splits a string on sub strings at each Unicode whitespace
-  occurrence with leading and trailing whitespace ignored.
-
-  ## Examples
-
-      iex> String.split("foo bar")
-      ["foo", "bar"]
-      iex> String.split("foo" <> <<194,133>> <> "bar")
-      ["foo", "bar"]
-      iex> String.split(" foo bar ")
-      ["foo", "bar"]
-
-  """
-  @spec split(t) :: [t]
-  defdelegate split(binary), to: String.Unicode
-
-  @doc """
-  Divides a string into sub strings based on a pattern,
-  returning a list of these sub string. The pattern can
-  be a string, a list of strings or a regular expression.
-
-  The string is split into as many parts as possible by
-  default, unless the `global` option is set to false.
-
-  ## Examples
-
-      iex> String.split("a,b,c", ",")
-      ["a", "b", "c"]
-      iex> String.split("a,b,c", ",", global: false)
-      ["a", "b,c"]
-
-      iex> String.split("1,2 3,4", [" ", ","])
-      ["1", "2", "3", "4"]
-
-      iex> String.split("a,b,c", %r{,})
-      ["a", "b", "c"]
-      iex> String.split("a,b,c", %r{,}, global: false)
-      ["a", "b,c"]
-      iex> String.split("a,b", %r{\\.})
-      ["a,b"]
-
-  """
-  @spec split(t, t | [t] | Regex.t) :: [t]
-  @spec split(t, t | [t] | Regex.t, Keyword.t) :: [t]
-  def split(binary, pattern, options // [])
-
-  def split(binary, pattern, options) when is_regex(pattern) do
-    Regex.split(pattern, binary, global: options[:global])
-  end
-
-  def split(binary, pattern, options) do
-    opts = if options[:global] != false, do: [:global], else: []
-    :binary.split(binary, pattern, opts)
-  end
-
-  @doc """
-  Convert all characters on the given string to upcase.
-
-  ## Examples
-
-      iex> String.upcase("abcd")
-      "ABCD"
-      iex> String.upcase("ab 123 xpto")
-      "AB 123 XPTO"
-      iex> String.upcase("josé")
-      "JOSÉ"
-
-  """
-  @spec upcase(t) :: t
-  defdelegate upcase(binary), to: String.Unicode
-
-  @doc """
-  Convert all characters on the given string to downcase.
-
-  ## Examples
-
-      iex> String.downcase("ABCD")
-      "abcd"
-      iex> String.downcase("AB 123 XPTO")
-      "ab 123 xpto"
-      iex> String.downcase("JOSÉ")
-      "josé"
-
-  """
-  @spec downcase(t) :: t
-  defdelegate downcase(binary), to: String.Unicode
-
-  @doc """
-  Converts the first character in the given string to
-  titlecase and the remaining to downcase.
-
-  This relies on the titlecase information provided
-  by the Unicode Standard. Note this function makes
-  no attempt in capitalizing all words in the string
-  (usually known as titlecase).
-
-  ## Examples
-
-      iex> String.capitalize("abcd")
-      "Abcd"
-      iex> String.capitalize("ﬁn")
-      "Fin"
-      iex> String.capitalize("josé")
-      "José"
-
-  """
-  @spec capitalize(t) :: t
-  def capitalize(string) when is_binary(string) do
-    { char, rest } = String.Unicode.titlecase_once(string)
-    char <> downcase(rest)
-  end
-
-  @doc """
-  Returns a string where trailing Unicode whitespace
-  has been removed.
-
-  ## Examples
-
-      iex> String.rstrip("   abc  ")
-      "   abc"
-
-  """
-  @spec rstrip(t) :: t
-  defdelegate rstrip(binary), to: String.Unicode
-
-  @doc """
-  Returns a string where trailing `char` have been removed.
-
-  ## Examples
-
-      iex> String.rstrip("   abc _", ?_)
-      "   abc "
-
-  """
-  @spec rstrip(t, char) :: t
-
-  def rstrip("", _char), do: ""
-
-  # Do a quick check before we traverse the whole
-  # binary. :binary.last is a fast operation (it
-  # does not traverse the whole binary).
-  def rstrip(string, char) do
-    if :binary.last(string) == char do
-      do_rstrip(string, "", char)
-    else
-      string
-    end
-  end
-
-  defp do_rstrip(<<char, string :: binary>>, buffer, char) do
-    do_rstrip(string, <<char, buffer :: binary>>, char)
-  end
-
-  defp do_rstrip(<<char, string :: binary>>, buffer, another_char) do
-    <<buffer :: binary, char, do_rstrip(string, "", another_char) :: binary>>
-  end
-
-  defp do_rstrip(<<>>, _, _) do
-    <<>>
-  end
-
-  @doc """
-  Returns a string where leading Unicode whitespace
-  has been removed.
-
-  ## Examples
-
-      iex> String.lstrip("   abc  ")
-      "abc  "
-
-  """
-  defdelegate lstrip(binary), to: String.Unicode
-
-  @doc """
-  Returns a string where leading `char` have been removed.
-
-  ## Examples
-
-      iex> String.lstrip("_  abc  _", ?_)
-      "  abc  _"
-
-  """
-
-  @spec lstrip(t, char) :: t
-
-  def lstrip(<<char, rest :: binary>>, char) do
-    <<lstrip(rest, char) :: binary>>
-  end
-
-  def lstrip(other, _char) do
-    other
-  end
-
-  @doc """
-  Returns a string where leading/trailing Unicode whitespace
-  has been removed.
-
-  ## Examples
-
-      iex> String.strip("   abc  ")
-      "abc"
-
-  """
-  @spec strip(t) :: t
-
-  def strip(string) do
-    rstrip(lstrip(string))
-  end
-
-  @doc """
-  Returns a string where leading/trailing `char` have been
-  removed.
-
-  ## Examples
-
-      iex> String.strip("a  abc  a", ?a)
-      "  abc  "
-
-  """
-  @spec strip(t, char) :: t
-
-  def strip(string, char) do
-    rstrip(lstrip(string, char), char)
-  end
-
-  @doc """
-  Returns a new binary based on `subject` by replacing the parts
-  matching `pattern` for `replacement`. By default, it replaces
-  all entries, except if the `global` option is set to false.
-
-  If the replaced part must be used in `replacement`, then the
-  position or the positions where it is to be inserted must be
-  specified by using the option `insert_replaced`.
-
-  ## Examples
-
-      iex> String.replace("a,b,c", ",", "-")
-      "a-b-c"
-      iex> String.replace("a,b,c", ",", "-", global: false)
-      "a-b,c"
-      iex> String.replace("a,b,c", "b", "[]", insert_replaced: 1)
-      "a,[b],c"
-      iex> String.replace("a,b,c", ",", "[]", insert_replaced: 2)
-      "a[],b[],c"
-      iex> String.replace("a,b,c", ",", "[]", insert_replaced: [1,1])
-      "a[,,]b[,,]c"
-
-  """
-  @spec replace(t, t, t) :: t
-  @spec replace(t, t, t, Keyword.t) :: t
-
-  def replace(subject, pattern, replacement, options // []) do
-    opts = translate_replace_options(options)
-    :binary.replace(subject, pattern, replacement, opts)
-  end
-
-  defp translate_replace_options(options) do
-    opts = if options[:global] != false, do: [:global], else: []
-
-    if insert = options[:insert_replaced] do
-      opts = [{:insert_replaced,insert}|opts]
-    end
-
-    opts
-  end
-
-  @doc """
-  Returns a binary `subject` duplicated `n` times.
-
-  ## Examples
-
-      iex> String.duplicate("abc", 1)
-      "abc"
-      iex> String.duplicate("abc", 2)
-      "abcabc"
-
-  """
-  @spec duplicate(t, pos_integer) :: t
-  def duplicate(subject, n) when is_integer(n) and n > 0 do
-    :binary.copy(subject, n)
-  end
-
-  @doc """
-  Returns all codepoints in the string.
-
-  ## Examples
-
-      iex> String.codepoints("josé")
-      ["j", "o", "s", "é"]
-      iex> String.codepoints("оптими зации")
-      ["о","п","т","и","м","и"," ","з","а","ц","и","и"]
-      iex> String.codepoints("ἅἪῼ")
-      ["ἅ","Ἢ","ῼ"]
-
-  """
-  @spec codepoints(t) :: [codepoint]
-  defdelegate codepoints(string), to: String.Unicode
-
-  @doc """
-  Returns the next codepoint in a String.
-
-  The result is a tuple with the codepoint and the
-  remaining of the string or `:no_codepoint` in case
-  the string reached its end.
-
-  As the other functions in the String module, this
-  function does not check for the validity of the codepoint.
-  That said, if an invalid codepoint is found, it will
-  be returned by this function.
-
-  ## Examples
-
-      iex> String.next_codepoint("josé")
-      { "j", "osé" }
-
-  """
-  @spec next_codepoint(t) :: {codepoint, t} | :no_codepoint
-  defdelegate next_codepoint(string), to: String.Unicode
-
-  @doc %B"""
-  Checks whether `str` contains only valid characters.
-
-  ## Examples
-
-      iex> String.valid?("a")
-      true
-      iex> String.valid?("ø")
-      true
-      iex> String.valid?(<<0xffff :: 16>>)
-      false
-      iex> String.valid?("asd" <> <<0xffff :: 16>>)
-      false
-
-  """
-  @spec valid?(t) :: boolean
-
-  noncharacters = Enum.to_list(?\x{FDD0}..?\x{FDEF}) ++
-    [ ?\x{0FFFE}, ?\x{0FFFF}, ?\x{1FFFE}, ?\x{1FFFF}, ?\x{2FFFE}, ?\x{2FFFF},
-      ?\x{3FFFE}, ?\x{3FFFF}, ?\x{4FFFE}, ?\x{4FFFF}, ?\x{5FFFE}, ?\x{5FFFF},
-      ?\x{6FFFE}, ?\x{6FFFF}, ?\x{7FFFE}, ?\x{7FFFF}, ?\x{8FFFE}, ?\x{8FFFF},
-      ?\x{9FFFE}, ?\x{9FFFF}, ?\x{10FFFE}, ?\x{10FFFF} ]
-
-  lc noncharacter inlist noncharacters do
-    def valid?(<< unquote(noncharacter) :: utf8, _ :: binary >>), do: false
-  end
-
-  def valid?(<<_ :: utf8, t :: binary>>), do: valid?(t)
-  def valid?(<<>>), do: true
-  def valid?(_), do: false
-
-  @doc %B"""
-  Checks whether `str` is a valid character.
-
-  All characters are codepoints, but some codepoints
-  are not valid characters. They may be reserved, private,
-  or other.
-
-  More info at: http://en.wikipedia.org/wiki/Mapping_of_Unicode_characters#Noncharacters
-
-  ## Examples
-
-      iex> String.valid_character?("a")
-      true
-      iex> String.valid_character?("ø")
-      true
-      iex> String.valid_character?("\x{ffff}")
-      false
-
-  """
-  @spec valid_character?(t) :: boolean
-
-  def valid_character?(<<_ :: utf8>> = codepoint), do: valid?(codepoint)
-  def valid_character?(_), do: false
-
-  @doc %B"""
-  Checks whether `str` is a valid codepoint.
-
-  Note that the empty string is considered invalid, as are
-  strings containing multiple codepoints.
-
-  ## Examples
-
-      iex> String.valid_codepoint?("a")
-      true
-      iex> String.valid_codepoint?("ø")
-      true
-      iex> String.valid_codepoint?(<<0xffff :: 16>>)
-      false
-      iex> String.valid_codepoint?("asdf")
-      false
-
-  """
-  @spec valid_codepoint?(codepoint) :: boolean
-  def valid_codepoint?(<<_ :: utf8>>), do: true
-  def valid_codepoint?(_), do: false
-
-  @doc """
-  Returns unicode graphemes in the string.
-
-  ## Examples
-
-      iex> String.graphemes("Ā̀stute")
-      ["Ā̀","s","t","u","t","e"]
-
-  """
-  @spec graphemes(t) :: [grapheme]
-  defdelegate graphemes(string), to: String.Unicode
-
-  @doc """
-  Returns the next grapheme in a String.
-
-  The result is a tuple with the grapheme and the
-  remaining of the string or `:no_grapheme` in case
-  the String reached its end.
-
-  ## Examples
-
-      iex> String.next_grapheme("josé")
-      { "j", "osé" }
-
-  """
-  @spec next_grapheme(t) :: { grapheme, t } | :no_grapheme
-  defdelegate next_grapheme(string), to: String.Unicode
-
-  @doc """
-  Returns the first grapheme from an utf8 string,
-  nil if the string is empty.
-
-  ## Examples
-
-      iex> String.first("elixir")
-      "e"
-      iex> String.first("եոգլի")
-      "ե"
-
-  """
-  @spec first(t) :: grapheme | nil
-  def first(string) do
-    case next_grapheme(string) do
-      { char, _ } -> char
-      :no_grapheme -> nil
-    end
-  end
-
-  @doc """
-  Returns the last grapheme from an utf8 string,
-  nil if the string is empty.
-
-  ## Examples
-
-      iex> String.last("elixir")
-      "r"
-      iex> String.last("եոգլի")
-      "ի"
-
-  """
-  @spec last(t) :: grapheme | nil
-  def last(string) do
-    do_last(next_grapheme(string), nil)
-  end
-
-  defp do_last({char, rest}, _) do
-    do_last(next_grapheme(rest), char)
-  end
-
-  defp do_last(:no_grapheme, last_char), do: last_char
-
-  @doc """
-  Returns the number of unicode graphemes in an utf8 string.
-
-  ## Examples
-
-      iex> String.length("elixir")
-      6
-      iex> String.length("եոգլի")
-      5
-
-  """
-  @spec length(t) :: non_neg_integer
-  def length(string) do
-    do_length(next_grapheme(string))
-  end
-
-  defp do_length({_, rest}) do
-    1 + do_length(next_grapheme(rest))
-  end
-
-  defp do_length(:no_grapheme), do: 0
-
-  @doc """
-  Returns the grapheme in the `position` of the given utf8 `string`.
-  If `position` is greater than `string` length, than it returns `nil`.
-
-  ## Examples
-
-      iex> String.at("elixir", 0)
-      "e"
-      iex> String.at("elixir", 1)
-      "l"
-      iex> String.at("elixir", 10)
-      nil
-      iex> String.at("elixir", -1)
-      "r"
-      iex> String.at("elixir", -10)
-      nil
-
-  """
-  @spec at(t, integer) :: grapheme | nil
-
-  def at(string, position) when position >= 0 do
-    do_at(next_grapheme(string), position, 0)
-  end
-
-  def at(string, position) when position < 0 do
-    real_pos = do_length(next_grapheme(string)) - abs(position)
-    case real_pos >= 0 do
-      true  -> do_at(next_grapheme(string), real_pos, 0)
-      false -> nil
-    end
-  end
-
-  defp do_at({_ , rest}, desired_pos, current_pos) when desired_pos > current_pos do
-    do_at(next_grapheme(rest), desired_pos, current_pos + 1)
-  end
-
-  defp do_at({char, _}, desired_pos, current_pos) when desired_pos == current_pos do
-    char
-  end
-
-  defp do_at(:no_grapheme, _, _), do: nil
-
-  @doc """
-  Returns a substring starting at the offset given by the first, and
-  a length given by the second.
-  If the offset is greater than string length, than it returns nil.
-
-  ## Examples
-
-      iex> String.slice("elixir", 1, 3)
-      "lix"
-      iex> String.slice("elixir", 1, 10)
-      "lixir"
-      iex> String.slice("elixir", 10, 3)
-      nil
-      iex> String.slice("elixir", -4, 4)
-      "ixir"
-      iex> String.slice("elixir", -10, 3)
-      nil
-      iex> String.slice("a", 0, 1500)
-      "a"
-      iex> String.slice("a", 1, 1500)
-      ""
-      iex> String.slice("a", 2, 1500)
-      nil
-
-  """
-  @spec slice(t, integer, integer) :: grapheme | nil
-
-  def slice(string, start, len) when start >= 0 do
-    do_slice(next_grapheme(string), start, start + len - 1, 0, "")
-  end
-
-  def slice(string, start, len) when start < 0 do
-    real_start_pos = do_length(next_grapheme(string)) - abs(start)
-    case real_start_pos >= 0 do
-      true -> do_slice(next_grapheme(string), real_start_pos, real_start_pos + len - 1, 0, "")
-      false -> nil
-    end
-  end
-
-  defp do_slice(_, start_pos, last_pos, _, _) when start_pos > last_pos do
-    nil
-  end
-
-  defp do_slice({_, rest}, start_pos, last_pos, current_pos, acc) when current_pos < start_pos do
-    do_slice(next_grapheme(rest), start_pos, last_pos, current_pos + 1, acc)
-  end
-
-  defp do_slice({char, rest}, start_pos, last_pos, current_pos, acc) when current_pos >= start_pos and current_pos < last_pos do
-    do_slice(next_grapheme(rest), start_pos, last_pos, current_pos + 1, acc <> char)
-  end
-
-  defp do_slice({char, _}, start_pos, last_pos, current_pos, acc) when current_pos >= start_pos and current_pos == last_pos do
-    acc <> char
-  end
-
-  defp do_slice(:no_grapheme, start_pos, _, current_pos, acc) when start_pos == current_pos do
-    acc
-  end
-
-  defp do_slice(:no_grapheme, _, _, _, acc) do
-    case acc do
-      "" -> nil
-      _ -> acc
-    end
-  end
-
-  @doc """
-  Converts a string to an integer. If successful, returns a
-  tuple of form {integer, remainder of string}. If unsuccessful,
-  returns :error.
-
-  ## Examples
-
-      iex> String.to_integer("34")
-      {34,""}
-      iex> String.to_integer("34.5")
-      {34,".5"}
-      iex> String.to_integer("three")
-      :error
-
-  """
-  @spec to_integer(t) :: {integer, t} | :error
-
-  def to_integer(string) do
-    {result, remainder} = :string.to_integer(binary_to_list(string))
-    case result do
-      :error -> :error
-      _ -> {result, list_to_binary(remainder)}
-    end
-  end
-
-  @doc """
-  Converts a string to a float. If successful, returns a
-  tuple of form {float, remainder of string}. If unsuccessful,
-  returns :error. If given an integer value, will return
-  same as to_integer/1.
-
-  ## Examples
-
-      iex> String.to_float("34")
-      {34.0,""}
-      iex> String.to_float("34.25")
-      {34.25,""}
-	    iex> String.to_float("56.5xyz")
-	    {56.5,"xyz"}
-      iex> String.to_float("pi")
-      :error
-
-  """
-  @spec to_float(t) :: {integer, t} | :error
-
-  def to_float(string) do
-    charlist = binary_to_list(string)
-    {result, remainder} = :string.to_float(charlist)
-    case result do
-      :error ->
-        {int_result, int_remainder} = :string.to_integer(charlist)
-        case int_result do
-          :error -> :error
-          _ -> {float(int_result), list_to_binary(int_remainder)}
-        end
-      _ -> {result, list_to_binary(remainder)}
-    end
-  end
-
-  @doc """
-  Returns true if `string` starts with any of the prefixes given, otherwise
-  false. `prefixes` can be either a single prefix or a list of prefixes.
-
-  ## Examples
-
-      iex> String.starts_with? "elixir", "eli"
-      true
-      iex> String.starts_with? "elixir", ["erlang", "elixir"]
-      true
-      iex> String.starts_with? "elixir", ["erlang", "ruby"]
-      false
-
-  """
-  @spec starts_with?(t, t | [t]) :: boolean
-
-  def starts_with?(string, prefixes) when is_list(prefixes) do
-    Enum.any?(prefixes, do_starts_with(string, &1))
-  end
-
-  def starts_with?(string, prefix) do
-    do_starts_with(string, prefix)
-  end
-
-  defp do_starts_with(_, "") do
-    true
-  end
-
-  defp do_starts_with(string, prefix) when is_binary(prefix) do
-    match?({0,_}, :binary.match(string, prefix))
-  end
-
-  defp do_starts_with(_, _) do
-    raise ArgumentError
-  end
-
-  @doc """
-  Returns true if `string` ends with any of the suffixes given, otherwise
-  false. `suffixes` can be either a single suffix or a list of suffixes.
-
-  ## Examples
-
-      iex> String.ends_with? "language", "age"
-      true
-      iex> String.ends_with? "language", ["youth", "age"]
-      true
-      iex> String.ends_with? "language", ["youth", "elixir"]
-      false
-
-  """
-  @spec ends_with?(t, t | [t]) :: boolean
-
-  def ends_with?(string, suffixes) when is_list(suffixes) do
-    Enum.any?(suffixes, do_ends_with(string, &1))
-  end
-
-  def ends_with?(string, suffix) do
-    do_ends_with(string, suffix)
-  end
-
-  defp do_ends_with(_, "") do
-    true
-  end
-
-  defp do_ends_with(string, suffix) when is_binary(suffix) do
-    string_size = size(string)
-    suffix_size = size(suffix)
-    scope = {string_size - suffix_size, suffix_size}
-    (suffix_size <= string_size) and (:nomatch != :binary.match(string, suffix, [scope: scope]))
-  end
-
-  defp do_ends_with(_, _) do
-    raise ArgumentError
-  end
-
-  @doc """
-  Returns true if `string` contains match, otherwise false.
-  `matches` can be either a single string or a list of strings.
-
-  ## Examples
-
-      iex> String.contains? "elixir of life", "of"
-      true
-      iex> String.contains? "elixir of life", ["life", "death"]
-      true
-      iex> String.contains? "elixir of life", ["death", "mercury"]
-      false
-
-  """
-  @spec contains?(t, t | [t]) :: boolean
-
-  def contains?(string, matches) when is_list(matches) do
-    Enum.any?(matches, do_contains(string, &1))
-  end
-
-  def contains?(string, match) do
-    do_contains(string, match)
-  end
-
-  defp do_contains(_, "") do
-    true
-  end
-
-  defp do_contains(string, match) when is_binary(match) do
-    :nomatch != :binary.match(string, match)
-  end
-
-  defp do_contains(_, _) do
-    raise ArgumentError
-  end
-end
@@ -1,183 +0,0 @@
-defmodule Supervisor.Behaviour do
-  @moduledoc """
-  This module is a convenience to define Supervisor
-  callbacks in Elixir. By using this module, you get
-  the module behaviour automatically tagged as
-  `:supervisor` and some helper functions are imported
-  to make defining supervisors easier.
-
-  For more information on supervisors, please check the
-  remaining functions defined in this module or refer to
-  the following:
-
-  http://www.erlang.org/doc/man/supervisor.html
-  http://www.erlang.org/doc/design_principles/sup_princ.html
-  http://learnyousomeerlang.com/supervisors
-
-  ## Example
-
-      defmodule ExUnit.Sup do
-        use Supervisor.Behaviour
-
-        def init(user_options) do
-          tree = [ worker(ExUnit.Runner, [user_options]) ]
-          supervise(tree, strategy: :one_for_one)
-        end
-      end
-
-      { :ok, pid } = :supervisor.start_link(MyServer, [])
-
-  """
-
-  @doc false
-  defmacro __using__(_) do
-    quote location: :keep do
-      @behaviour :supervisor
-      import unquote(__MODULE__)
-    end
-  end
-
-  @doc """
-  Receives a list of children (worker or supervisors) to
-  supervise and a set of options. Returns a tuple containing
-  the supervisor specification.
-
-  ## Examples
-
-      supervise children, strategy: :one_for_one
-
-  ## Options
-
-  * `:strategy` - the restart strategy option It can be either
-    `:one_for_one`, `:rest_for_one`, `:one_for_all` and
-    `:simple_one_for_one`;
-
-  * `:max_restarts` - the maximum amount of restarts allowed in
-    a time frame. Defaults to 5;
-
-  * `:max_seconds` - the time frame in which max_restarts applies.
-    Defaults to 5;
-
-  The `:strategy` option is required and by default maximum 5 restarts
-  are allowed in 5 seconds.
-
-  ## Strategies
-
-  * `:one_for_one` - If a child process terminates, only that
-    process is restarted;
-
-  * `:one_for_all` - If a child process terminates, all other child
-    processes are terminated and then all child processes, including
-    the terminated one, are restarted;
-
-  * `:rest_for_one` - If a child process terminates, the "rest" of
-    the child processes, i.e. the child processes after the terminated
-    process in start order, are terminated. Then the terminated child
-    process and the rest of the child processes are restarted;
-
-  * `:simple_one_for_one` - Similar to `:one_for_one` but suits better
-    when dynamically attaching children;
-
-  """
-  def supervise(children, options) do
-    unless strategy = options[:strategy] do
-      raise ArgumentError, message: "expected :strategy option to be given to supervise"
-    end
-
-    maxR = Keyword.get(options, :max_restarts, 5)
-    maxS = Keyword.get(options, :max_seconds, 5)
-
-    { :ok, { { strategy, maxR, maxS }, children } }
-  end
-
-  @child_doc """
-  ## Options
-
-  * `:id` - a name used to identify the child specification
-    internally by the supervisor. Defaults to the module name;
-
-  * `:function` - the function to invoke on the child to start it.
-    Defaults to `:start_link`;
-
-  * `:restart` - defines when the child process should restart.
-    Defaults to `:permanent`;
-
-  * `:shutdown` - defines how a child process should be terminated.
-    Defaults to `5000`;
-
-  * `:modules` - it should be a list with one element `[module]`,
-    where module is the name of the callback module only if the
-    child process is a supervisor, gen_server or gen_fsm. If the
-    child process is a gen_event, modules should be `:dynamic`.
-    Defaults to a list with the given module;
-
-  ## Restart values
-
-  The following restart values are supported:
-
-  * `:permanent` - the child process is always restarted;
-
-  * `:temporary` - the child process is never restarted (not even
-    when the supervisor's strategy is `:rest_for_one` or `:one_for_all`);
-
-  * `:transient` - the child process is restarted only if it
-    terminates abnormally, i.e. with another exit reason than
-    `:normal`, `:shutdown` or `{ :shutdown, term }`;
-
-  ## Shutdown values
-
-  The following shutdown values are supported:
-
-  * `:brutal_kill` - the child process is unconditionally terminated
-    using `exit(child, :kill)`;
-
-  * `:infinity` - if the child process is a supervisor, it is a mechanism
-    to give the subtree enough time to shutdown. It can also be used with
-    workers with care;
-
-  * Finally, it can also be any integer meaning that the supervisor tells
-    the child process to terminate by calling `exit(child, :shutdown)` and
-    then waits for an exit signal back. If no exit signal is received within
-    the specified time (in miliseconds), the child process is unconditionally
-    terminated using `exit(child, :kill)`;
-  """
-
-  @doc """
-  Defines the given `module` as a worker which will be started
-  with the given arguments.
-
-      worker ExUnit.Runner, [], restart: :permanent
-
-  By default, the function `:start_link` is invoked on the given module.
-
-  #{@child_doc}
-  """
-  def worker(module, args, options // []) do
-    child(:worker, module, args, options)
-  end
-
-  @doc """
-  Defines the given `module` as a supervisor which will be started
-  with the given arguments.
-
-      supervisor ExUnit.Runner, [], restart: :permanent
-
-  By default, the function `:start_link` is invoked on the given module.
-
-  #{@child_doc}
-  """
-  def supervisor(module, args, options // []) do
-    child(:supervisor, module, args, options)
-  end
-
-  defp child(type, module, args, options) do
-    id       = Keyword.get(options, :id, module)
-    modules  = Keyword.get(options, :modules, [module])
-    function = Keyword.get(options, :function, :start_link)
-    restart  = Keyword.get(options, :restart, :permanent)
-    shutdown = Keyword.get(options, :shutdown, 5000)
-
-    { id, { module, function, args },
-      restart, shutdown, type, modules }
-  end
-end
@@ -1,337 +0,0 @@
-defmodule System do
-  defexception NoHomeError,
-    message: "could not find the user home, please set the HOME environment variable"
-
-  defexception NoTmpDirError,
-    message: "could not get a writable temporary directory, please set the TMPDIR environment variable"
-
-  defexception NoAccessCwdError,
-    message: "could not get a current working directory, the current location is not accessible"
-
-  @moduledoc """
-  The System module provides access to some variables used or
-  maintained by the VM and to functions that interact strongly
-  with the VM or the host system.
-  """
-
-  defp strip_re(iodata, pattern) do
-    :re.replace(iodata, pattern, "", [return: :binary])
-  end
-
-  defp read_stripped(path) do
-    case :file.read_file(path) do
-      { :ok, binary } ->
-        strip_re(binary, "^\s+|\s+$")
-      _ -> ""
-    end
-  end
-
-  # Read and strip the version from the `VERSION` file.
-  defmacrop get_version do
-    case read_stripped("VERSION") do
-      ""   -> raise CompileError, message: "could not read the version number from VERSION"
-      data -> data
-    end
-  end
-
-  # Tries to run `git describe --always --tags`. In the case of success returns
-  # the most recent tag. If that is not available, tries to read the commit hash
-  # from .git/HEAD. If that fails, returns an empty string.
-  defmacrop get_describe do
-    dirpath = ".git"
-    case :file.read_file_info(dirpath) do
-      { :ok, _ } ->
-        if :os.find_executable('git') do
-          data = :os.cmd('git describe --always --tags')
-          strip_re(data, "\n")
-        else
-          read_stripped(:filename.join(".git", "HEAD"))
-        end
-      _ -> ""
-    end
-  end
-
-  # Get the date at compilation time.
-  defmacrop get_date do
-    list_to_binary :httpd_util.rfc1123_date
-  end
-
-  @doc """
-  Returns Elixir's version as binary.
-  """
-  @spec version() :: String.t
-  def version, do: get_version
-
-  @doc """
-  Returns a keywords list with version, git tag info and date.
-  """
-  @spec build_info() :: Keyword.t
-  def build_info do
-    [version: version, tag: get_describe, date: get_date]
-  end
-
-  @doc """
-  Returns the list of command-line arguments passed to the program.
-  """
-  @spec argv() :: [String.t]
-  def argv do
-    :elixir_code_server.call :argv
-  end
-
-  @doc """
-  Returns the current working directory or nil if one
-  is not available.
-  """
-  def cwd do
-    case :file.get_cwd do
-      { :ok, list } -> :unicode.characters_to_binary(list)
-      _ -> nil
-    end
-  end
-
-  @doc """
-  Returns the current working directory or raises `System.NoAccessCwdError`.
-  """
-  def cwd! do
-    cwd || raise NoAccessCwdError
-  end
-
-  @doc """
-  Returns the user home (platform independent).
-  It returns nil if no user home is set.
-  """
-  def user_home do
-    get_unix_home || get_windows_home
-  end
-
-  @doc """
-  Same as `user_home` but raises `System.NoHomeError`
-  instead of returning nil if no user home is set.
-  """
-  def user_home! do
-    user_home || raise NoHomeError
-  end
-
-  defp get_unix_home do
-    get_env("HOME")
-  end
-
-  defp get_windows_home do
-    get_env("USERPROFILE") || (
-      hd = get_env("HOMEDRIVE")
-      hp = get_env("HOMEPATH")
-      hd && hp && hd <> hp
-    )
-  end
-
-  @doc %B"""
-  Returns a writable temporary directory.
-  It searches for directories in the following order:
-
-  1. The directory named by the TMPDIR environment variable
-  2. The directory named by the TEMP environment variable
-  3. The directory named by the TMP environment variable
-  4. `C:\TMP` on Windows or `/tmp` on Unix
-  5.  As a last resort, the current working directory
-
-  Returns nil if none of the above are writable.
-  """
-  def tmp_dir do
-    write_env_tmp_dir('TMPDIR') ||
-      write_env_tmp_dir('TEMP')  ||
-      write_env_tmp_dir('TMP') ||
-      write_tmp_dir("/tmp")     ||
-      ((cwd = cwd()) && write_tmp_dir(cwd))
-  end
-
-  @doc """
-  Same as `tmp_dir` but raises `System.NoTmpDirError`
-  instead of returning nil if no temp dir is set.
-  """
-  def tmp_dir! do
-    tmp_dir || raise NoTmpDirError
-  end
-
-  defp write_env_tmp_dir(env) do
-    case get_env(env) do
-      nil -> nil
-      tmp -> write_tmp_dir tmp
-    end
-  end
-
-  defp write_tmp_dir(dir) do
-    case :file.read_file_info(dir) do
-      {:ok, info} ->
-        type_index = File.Stat.__index__ :type
-        access_index = File.Stat.__index__ :access
-        case { elem(info, type_index), elem(info, access_index) } do
-          { :directory, access } when access in [:read_write, :write] ->
-            dir
-          _ -> nil
-        end
-      { :error, _ } -> nil
-    end
-  end
-
-  @doc """
-  Registers a function that will be invoked
-  at the end of program execution. Useful for
-  invoking a hook in a "script" mode.
-
-  The function must expect the exit status code
-  as argument.
-  """
-  def at_exit(fun) when is_function(fun, 1) do
-    :elixir_code_server.cast { :at_exit, fun }
-  end
-
-  @doc """
-  Executes `command` in a command shell of the target OS,
-  captures the standard output of the command and returns
-  the result as a binary.
-
-  If `command` is a char list, a char list is returned.
-  Returns a binary otherwise.
-  """
-  @spec cmd(char_list) :: char_list
-  @spec cmd(String.t) :: String.t
-  def cmd(command) when is_list(command) do
-    :os.cmd(command)
-  end
-
-  def cmd(command) do
-    list_to_binary :os.cmd(to_char_list(command))
-  end
-
-  @doc """
-  This function looks up an executable program given
-  its name using the environment variable PATH on Unix
-  and Windows. It also considers the proper executable
-  extension for each OS, so for Windows it will try to
-  lookup files with `.com`, `.cmd` or similar extensions.
-
-  If `program` is a char list, a char list is returned.
-  Returns a binary otherwise.
-  """
-  @spec find_executable(char_list) :: char_list | nil
-  @spec find_executable(String.t) :: String.t | nil
-  def find_executable(program) when is_list(program) do
-    :os.find_executable(program) || nil
-  end
-
-  def find_executable(program) do
-    case :os.find_executable(to_char_list(program)) do
-      false -> nil
-      other -> list_to_binary(other)
-    end
-  end
-
-  @doc """
-  Returns a list of all environment variables. Each environment variable is
-  given as a single string of the format "VarName=Value", where VarName is the
-  name of the variable and Value its value.
-  """
-  @spec get_env() :: [{String.t, String.t}]
-  def get_env do
-    Enum.map :os.getenv, :unicode.characters_to_binary &1
-  end
-
-  @doc """
-  Returns the value of the environment variable
-  `varname` as a binary, or nil if the environment
-  variable is undefined.
-  """
-  @spec get_env(String.t) :: String.t | nil
-  def get_env(varname) do
-    case :os.getenv(to_char_list(varname)) do
-      false -> nil
-      other -> :unicode.characters_to_binary(other)
-    end
-  end
-
-  @doc """
-  Returns the process identifier of the current Erlang emulator
-  in the format most commonly used by the operating system environment.
-
-  See http://www.erlang.org/doc/man/os.html#getpid-0 for more info.
-  """
-  @spec get_pid() :: String.t
-  def get_pid, do: list_to_binary(:os.getpid)
-
-  @doc """
-  Sets a new `value` for the environment variable `varname`.
-  """
-  @spec put_env(String.t, String.t | char_list) :: :ok
-  def put_env(varname, value) when is_binary(value) or is_list(value) do
-   :os.putenv to_char_list(varname), :unicode.characters_to_list(value)
-   :ok
-  end
-
-  @doc """
-  Sets a new value for each environment variable corresponding
-  to each key in `dict`.
-  """
-  @spec put_env(Dict.t) :: :ok
-  def put_env(dict) do
-    Enum.each dict, fn {key, val} -> put_env key, val end
-  end
-
-  @doc """
-  Gets Elixir's stacktrace.
-
-  Notice the Erlang VM (and therefore this function) does not
-  return the current stacktrace but rather the stacktrace of the
-  latest exception.
-  """
-  def stacktrace do
-    filter_stacktrace :erlang.get_stacktrace
-  end
-
-  @doc """
-  Halts the Erlang runtime system where the first argument status must be a
-  non-negative integer, the atom `:abort` or any type that can be converted
-  to a char list.
-
-  * If an integer, the runtime system exits with the integer value which
-    is returned to the Operating System;
-
-  * If `:abort`, the runtime system aborts producing a core dump, if that is
-    enabled in the operating system;
-
-  * If a char list, an erlang crash dump is produced with status as slogan,
-    and then the runtime system exits with status code 1;
-
-  Note that on many platforms, only the status codes 0-255 are supported
-  by the operating system.
-
-  For integer status, Erlang runtime system closes all ports and allows async
-  threads to finish their operations before exiting. To exit without such
-  flushing, pass options [flush: false] instead.
-
-  For more information, check: http://www.erlang.org/doc/man/erlang.html#halt-2
-
-  ## Examples
-
-      System.halt(0)
-      System.halt(1, flush: false)
-      System.halt(:abort)
-
-  """
-  @spec halt() :: no_return
-  @spec halt(non_neg_integer | List.Chars.t | :abort) :: no_return
-  @spec halt(non_neg_integer | List.Chars.t | :abort, [] | [flush: false]) :: no_return
-  def halt(status // 0, options // [])
-
-  def halt(status, options) when is_integer(status) or status == :abort do
-    :erlang.halt(status, options)
-  end
-
-  def halt(status, options) do
-    :erlang.halt(to_char_list(status), options)
-  end
-
-  ## Helpers
-
-  defp filter_stacktrace([{ Kernel, :raise, _, _ }|t]), do: t
-  defp filter_stacktrace(t), do: t
-end
@@ -1,3 +0,0 @@
-defmodule Tuple do
-  @moduledoc false
-end
@@ -1,229 +0,0 @@
-defmodule URI do
-  @on_load :preload_parsers
-
-  defrecord Info, [scheme: nil, path: nil, query: nil,
-                   fragment: nil, authority: nil,
-                   userinfo: nil, host: nil, port: nil,
-                   specifics: nil]
-
-  import Bitwise
-
-  @moduledoc """
-  Utilities for working with and creating URIs.
-  """
-
-  @doc """
-  Takes an enumerable (containing a sequence of two-item tuples)
-  and returns a string of k=v&k2=v2... where keys and values are
-  URL encoded as per encode. Keys and values can be any term
-  that implements the Binary.Chars protocol (i.e. can be converted
-  to binary).
-  """
-  def encode_query(l), do: Enum.map_join(l, "&", pair(&1))
-
-  @doc """
-  Given a query string of the form "key1=value1&key=value2...", produces an
-  orddict with one entry for each key-value pair. Each key and value will be a
-  binary. It also does percent-unescaping of both keys and values.
-
-  Use decoder/1 if you want to customize or iterate each value manually.
-  """
-  def decode_query(q, dict // HashDict.new) when is_binary(q) do
-    Enum.reduce query_decoder(q), dict, fn({ k, v }, acc) -> Dict.put(acc, k, v) end
-  end
-
-  @doc """
-  Returns an iterator function over the query string that decodes
-  the query string in steps.
-  """
-  def query_decoder(q) when is_binary(q) do
-    fn(acc, fun) ->
-      do_decoder(q, acc, fun)
-    end
-  end
-
-  defp do_decoder("", acc, _fun) do
-    acc
-  end
-
-  defp do_decoder(q, acc, fun) do
-    next =
-      case :binary.split(q, "&") do
-        [first, rest] -> rest
-        [first]       -> ""
-      end
-
-    current =
-      case :binary.split(first, "=") do
-        [ key, value ] -> { decode(key), decode(value) }
-        [ key ]        -> { decode(key), nil }
-      end
-
-    do_decoder(next, fun.(current, acc), fun)
-  end
-
-  defp pair({k, v}) do
-    encode(to_binary(k)) <> "=" <> encode(to_binary(v))
-  end
-
-  @doc """
-  Percent (URL) encodes a URI.
-  """
-  def encode(s), do: bc <<c>> inbits s, do: <<percent(c) :: binary>>
-
-  defp percent(32), do: <<?+>>
-  defp percent(?-), do: <<?->>
-  defp percent(?_), do: <<?_>>
-  defp percent(?.), do: <<?.>>
-
-  defp percent(c)
-      when c >= ?0 and c <= ?9
-      when c >= ?a and c <= ?z
-      when c >= ?A and c <= ?Z do
-    <<c>>
-  end
-
-  defp percent(c), do: "%" <> hex(bsr(c, 4)) <> hex(band(c, 15))
-
-  defp hex(n) when n <= 9, do: <<n + ?0>>
-  defp hex(n), do: <<n + ?A - 10>>
-
-  @doc """
-  Unpercent (URL) decodes a URI.
-  """
-  def decode(<<?%, hex1, hex2, tail :: binary >>) do
-    << bsl(hex2dec(hex1), 4) + hex2dec(hex2) >> <> decode(tail)
-  end
-
-  def decode(<<head, tail :: binary >>) do
-    <<check_plus(head)>> <> decode(tail)
-  end
-
-  def decode(<<>>), do: <<>>
-
-  defp hex2dec(n) when n in ?A..?F, do: n - ?A + 10
-  defp hex2dec(n) when n in ?0..?9, do: n - ?0
-
-  defp check_plus(?+), do: 32
-  defp check_plus(c),  do: c
-
-  @doc """
-  Parses a URI into components.
-
-  URIs have portions that are handled specially for the
-  particular scheme of the URI. For example, http and https
-  have different default ports. Sometimes the parsing
-  of portions themselves are different. This parser
-  is extensible via behavior modules. If you have a
-  module named URI.MYSCHEME with a function called
-  'parse' that takes a single argument, the generically
-  parsed URI, that function will be called when this
-  parse function is passed a URI of that scheme. This
-  allows you to build on top of what the URI library
-  currently offers. You also need to define default_port
-  which takes 0 arguments and returns the default port
-  for that particular scheme. Take a look at URI.HTTPS for an
-  example of one of these extension modules.
-  """
-  def parse(s) when is_binary(s) do
-    # From http://tools.ietf.org/html/rfc3986#appendix-B
-    regex = %r/^(([^:\/?#]+):)?(\/\/([^\/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/
-    parts = nillify(Regex.run(regex, s))
-
-    destructure [_, _, scheme, _, authority, path, _, query, _, fragment], parts
-    { userinfo, host, port } = split_authority(authority)
-
-    if authority do
-      authority = ""
-
-      if userinfo, do: authority = authority <> userinfo <> "@"
-      if host, do: authority = authority <> host
-      if port, do: authority = authority <> ":" <> integer_to_binary(port)
-    end
-
-    info = URI.Info[
-      scheme: scheme && String.downcase(scheme), path: path, query: query,
-      fragment: fragment, authority: authority,
-      userinfo: userinfo, host: host, port: port
-    ]
-
-    scheme_specific(scheme, info)
-  end
-
-  @doc false
-  def scheme_module(scheme) do
-    if scheme do
-      module =
-        try do
-          Module.safe_concat(URI, String.upcase(scheme))
-        rescue
-          ArgumentError -> nil
-        end
-
-      if module && Code.ensure_loaded?(module) do
-        module
-      end
-    end
-  end
-
-  defp scheme_specific(scheme, info) do
-    if module = scheme_module(scheme) do
-      module.parse(default_port(info, module))
-    else
-      info
-    end
-  end
-
-  defp default_port(info, module) do
-    if info.port, do: info, else: info.port(module.default_port)
-  end
-
-  # Split an authority into its userinfo, host and port parts.
-  defp split_authority(s) do
-    s = s || ""
-    components = Regex.run %r/(^(.*)@)?([^:]*)(:(\d*))?/, s
-    destructure [_, _, userinfo, host, _, port], nillify(components)
-    port = if port, do: binary_to_integer(port)
-    { userinfo, host && String.downcase(host), port }
-  end
-
-  # Regex.run returns empty strings sometimes. We want
-  # to replace those with nil for consistency.
-  defp nillify(l) do
-    lc s inlist l do
-      if size(s) > 0 do
-        s
-      else
-        nil
-      end
-    end
-  end
-
-  # Reference parsers so the parse/1 doesn't fail
-  # on safe_concat.
-  defp preload_parsers do
-    parsers = [URI.FTP, URI.HTTP, URI.HTTPS, URI.LDAP, URI.SFTP, URI.TFTP]
-    Enum.each parsers, Code.ensure_loaded(&1)
-    :ok
-  end
-end
-
-defimpl Binary.Chars, for: URI.Info do
-  def to_binary(uri) do
-    result = ""
-
-    if module = URI.scheme_module(uri.scheme) do
-      if module.default_port == uri.port, do: uri = uri.port(nil)
-    end
-
-    if uri.scheme,   do: result = result <> uri.scheme <> "://"
-    if uri.userinfo, do: result = result <> uri.userinfo <> "@"
-    if uri.host,     do: result = result <> uri.host
-    if uri.port,     do: result = result <> ":" <> integer_to_binary(uri.port)
-    if uri.path,     do: result = result <> uri.path
-    if uri.query,    do: result = result <> "?" <> uri.query
-    if uri.fragment, do: result = result <> "#" <> uri.fragment
-
-    result
-  end
-end
@@ -1,5 +0,0 @@
-defmodule URI.FTP do
-  @behavior URI.Parser
-  def default_port(), do: 21
-  def parse(info), do: info
-end
@@ -1,5 +0,0 @@
-defmodule URI.HTTP do
-  @behavior URI.Parser
-  def default_port(), do: 80
-  def parse(info), do: info
-end
@@ -1,5 +0,0 @@
-defmodule URI.HTTPS do
-  @behavior URI.Parser
-  def default_port(), do: 443
-  def parse(info), do: info
-end
@@ -1,7 +0,0 @@
-defmodule URI.LDAP do
-  @behavior URI.Parser
-  def default_port(), do: 389
-
-  # TODO: LDAP specific parsing.
-  def parse(info), do: info
-end
@@ -1,18 +0,0 @@
-defmodule URI.Parser do
-  @moduledoc """
-  Defines the behavior for each URI.Parser.
-  Check URI.HTTP for a possible implementation.
-  """
-
-  use Behaviour
-
-  @doc """
-  Responsible for parsing extra URL information.
-  """
-  defcallback parse(uri_info :: URI.Info.t) :: URI.Info.t
-
-  @doc """
-  Responsible for returning the default port.
-  """
-  defcallback default_port() :: integer
-end
@@ -1,5 +0,0 @@
-defmodule URI.SFTP do
-  @behavior URI.Parser
-  def default_port(), do: 22
-  def parse(info), do: info
-end
@@ -1,5 +0,0 @@
-defmodule URI.TFTP do
-  @behavior URI.Parser
-  def default_port(), do: 69
-  def parse(info), do: info
-end
@@ -1,11 +0,0 @@
-defmodule Elixir.Mixfile do
-  use Mix.Project
-
-  def project do
-    [ app: :elixir,
-      version: System.version,
-      escript_embed_elixir: false,
-      escript_main_module: :elixir,
-      escript_emu_args: "%%! -noshell\n" ]
-  end
-end
@@ -1,420 +0,0 @@
-LATIN CAPITAL LETTER A WITH MACRON AND GRAVE;0100 0300
-LATIN SMALL LETTER A WITH MACRON AND GRAVE;0101 0300
-LATIN CAPITAL LETTER E WITH VERTICAL LINE BELOW;0045 0329
-LATIN SMALL LETTER E WITH VERTICAL LINE BELOW;0065 0329
-LATIN CAPITAL LETTER E WITH VERTICAL LINE BELOW AND GRAVE;00C8 0329
-LATIN SMALL LETTER E WITH VERTICAL LINE BELOW AND GRAVE;00E8 0329
-LATIN CAPITAL LETTER E WITH VERTICAL LINE BELOW AND ACUTE;00C9 0329
-LATIN SMALL LETTER E WITH VERTICAL LINE BELOW AND ACUTE;00E9 0329
-LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND MACRON;00CA 0304
-LATIN SMALL LETTER E WITH CIRCUMFLEX AND MACRON;00EA 0304
-LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND CARON;00CA 030C
-LATIN SMALL LETTER E WITH CIRCUMFLEX AND CARON;00EA 030C
-LATIN CAPITAL LETTER I WITH MACRON AND GRAVE;012A 0300
-LATIN SMALL LETTER I WITH MACRON AND GRAVE;012B 0300
-LATIN SMALL LETTER I WITH DOT ABOVE AND ACUTE;0069 0307 0301
-LATIN SMALL LETTER NG WITH TILDE ABOVE;006E 0360 0067
-LATIN CAPITAL LETTER O WITH VERTICAL LINE BELOW;004F 0329
-LATIN SMALL LETTER O WITH VERTICAL LINE BELOW;006F 0329
-LATIN CAPITAL LETTER O WITH VERTICAL LINE BELOW AND GRAVE;00D2 0329
-LATIN SMALL LETTER O WITH VERTICAL LINE BELOW AND GRAVE;00F2 0329
-LATIN CAPITAL LETTER O WITH VERTICAL LINE BELOW AND ACUTE;00D3 0329
-LATIN SMALL LETTER O WITH VERTICAL LINE BELOW AND ACUTE;00F3 0329
-LATIN CAPITAL LETTER S WITH VERTICAL LINE BELOW;0053 0329
-LATIN SMALL LETTER S WITH VERTICAL LINE BELOW;0073 0329
-LATIN CAPITAL LETTER U WITH MACRON AND GRAVE;016A 0300
-LATIN SMALL LETTER U WITH MACRON AND GRAVE;016B 0300
-LATIN CAPITAL LETTER A WITH OGONEK AND ACUTE;0104 0301
-LATIN SMALL LETTER A WITH OGONEK AND ACUTE;0105 0301
-LATIN CAPITAL LETTER A WITH OGONEK AND TILDE;0104 0303
-LATIN SMALL LETTER A WITH OGONEK AND TILDE;0105 0303
-LATIN CAPITAL LETTER E WITH OGONEK AND ACUTE;0118 0301
-LATIN SMALL LETTER E WITH OGONEK AND ACUTE;0119 0301
-LATIN CAPITAL LETTER E WITH OGONEK AND TILDE;0118 0303
-LATIN SMALL LETTER E WITH OGONEK AND TILDE;0119 0303
-LATIN CAPITAL LETTER E WITH DOT ABOVE AND ACUTE;0116 0301
-LATIN SMALL LETTER E WITH DOT ABOVE AND ACUTE;0117 0301
-LATIN CAPITAL LETTER E WITH DOT ABOVE AND TILDE;0116 0303
-LATIN SMALL LETTER E WITH DOT ABOVE AND TILDE;0117 0303
-LATIN SMALL LETTER I WITH DOT ABOVE AND GRAVE;0069 0307 0300
-LATIN SMALL LETTER I WITH DOT ABOVE AND TILDE;0069 0307 0303
-LATIN CAPITAL LETTER I WITH OGONEK AND ACUTE;012E 0301
-LATIN SMALL LETTER I WITH OGONEK AND DOT ABOVE AND ACUTE;012F 0307 0301
-LATIN CAPITAL LETTER I WITH OGONEK AND TILDE;012E 0303
-LATIN SMALL LETTER I WITH OGONEK AND DOT ABOVE AND TILDE;012F 0307 0303
-LATIN CAPITAL LETTER J WITH TILDE;004A 0303
-LATIN SMALL LETTER J WITH DOT ABOVE AND TILDE;006A 0307 0303
-LATIN CAPITAL LETTER L WITH TILDE;004C 0303
-LATIN SMALL LETTER L WITH TILDE;006C 0303
-LATIN CAPITAL LETTER M WITH TILDE;004D 0303
-LATIN SMALL LETTER M WITH TILDE;006D 0303
-LATIN CAPITAL LETTER R WITH TILDE;0052 0303
-LATIN SMALL LETTER R WITH TILDE;0072 0303
-LATIN CAPITAL LETTER U WITH OGONEK AND ACUTE;0172 0301
-LATIN SMALL LETTER U WITH OGONEK AND ACUTE;0173 0301
-LATIN CAPITAL LETTER U WITH OGONEK AND TILDE;0172 0303
-LATIN SMALL LETTER U WITH OGONEK AND TILDE;0173 0303
-LATIN CAPITAL LETTER U WITH MACRON AND ACUTE;016A 0301
-LATIN SMALL LETTER U WITH MACRON AND ACUTE;016B 0301
-LATIN CAPITAL LETTER U WITH MACRON AND TILDE;016A 0303
-LATIN SMALL LETTER U WITH MACRON AND TILDE;016B 0303
-LATIN SMALL LETTER AE WITH GRAVE;00E6 0300
-LATIN SMALL LETTER OPEN O WITH GRAVE;0254 0300
-LATIN SMALL LETTER OPEN O WITH ACUTE;0254 0301
-LATIN SMALL LETTER TURNED V WITH GRAVE;028C 0300
-LATIN SMALL LETTER TURNED V WITH ACUTE;028C 0301
-LATIN SMALL LETTER SCHWA WITH GRAVE;0259 0300
-LATIN SMALL LETTER SCHWA WITH ACUTE;0259 0301
-LATIN SMALL LETTER HOOKED SCHWA WITH GRAVE;025A 0300
-LATIN SMALL LETTER HOOKED SCHWA WITH ACUTE;025A 0301
-BENGALI LETTER KHINYA;0995 09CD 09B7
-TAMIL CONSONANT K;  0B95 0BCD
-TAMIL CONSONANT NG; 0B99 0BCD
-TAMIL CONSONANT C;  0B9A 0BCD
-TAMIL CONSONANT NY; 0B9E 0BCD
-TAMIL CONSONANT TT; 0B9F 0BCD
-TAMIL CONSONANT NN; 0BA3 0BCD
-TAMIL CONSONANT T;  0BA4 0BCD
-TAMIL CONSONANT N;  0BA8 0BCD
-TAMIL CONSONANT P;  0BAA 0BCD
-TAMIL CONSONANT M;  0BAE 0BCD
-TAMIL CONSONANT Y;  0BAF 0BCD
-TAMIL CONSONANT R;  0BB0 0BCD
-TAMIL CONSONANT L;  0BB2 0BCD
-TAMIL CONSONANT V;  0BB5 0BCD
-TAMIL CONSONANT LLL;0BB4 0BCD
-TAMIL CONSONANT LL; 0BB3 0BCD
-TAMIL CONSONANT RR; 0BB1 0BCD
-TAMIL CONSONANT NNN;0BA9 0BCD
-TAMIL CONSONANT J;  0B9C 0BCD
-TAMIL CONSONANT SH; 0BB6 0BCD
-TAMIL CONSONANT SS; 0BB7 0BCD
-TAMIL CONSONANT S;  0BB8 0BCD
-TAMIL CONSONANT H;  0BB9 0BCD
-TAMIL CONSONANT KSS;0B95 0BCD 0BB7 0BCD
-TAMIL SYLLABLE KAA; 0B95 0BBE
-TAMIL SYLLABLE KI;  0B95 0BBF
-TAMIL SYLLABLE KII; 0B95 0BC0
-TAMIL SYLLABLE KU;  0B95 0BC1
-TAMIL SYLLABLE KUU; 0B95 0BC2
-TAMIL SYLLABLE KE;  0B95 0BC6
-TAMIL SYLLABLE KEE; 0B95 0BC7
-TAMIL SYLLABLE KAI; 0B95 0BC8
-TAMIL SYLLABLE KO;  0B95 0BCA
-TAMIL SYLLABLE KOO; 0B95 0BCB
-TAMIL SYLLABLE KAU; 0B95 0BCC
-TAMIL SYLLABLE NGAA; 0B99 0BBE
-TAMIL SYLLABLE NGI;  0B99 0BBF
-TAMIL SYLLABLE NGII; 0B99 0BC0
-TAMIL SYLLABLE NGU;  0B99 0BC1
-TAMIL SYLLABLE NGUU; 0B99 0BC2
-TAMIL SYLLABLE NGE;  0B99 0BC6
-TAMIL SYLLABLE NGEE; 0B99 0BC7
-TAMIL SYLLABLE NGAI; 0B99 0BC8
-TAMIL SYLLABLE NGO;  0B99 0BCA
-TAMIL SYLLABLE NGOO; 0B99 0BCB
-TAMIL SYLLABLE NGAU; 0B99 0BCC
-TAMIL SYLLABLE CI;  0B9A 0BBF
-TAMIL SYLLABLE CII; 0B9A 0BC0
-TAMIL SYLLABLE CU;  0B9A 0BC1
-TAMIL SYLLABLE CUU; 0B9A 0BC2
-TAMIL SYLLABLE CE;  0B9A 0BC6
-TAMIL SYLLABLE CEE; 0B9A 0BC7
-TAMIL SYLLABLE CAI; 0B9A 0BC8
-TAMIL SYLLABLE CO;  0B9A 0BCA
-TAMIL SYLLABLE COO; 0B9A 0BCB
-TAMIL SYLLABLE CAU; 0B9A 0BCC
-TAMIL SYLLABLE NYAA; 0B9E 0BBE
-TAMIL SYLLABLE NYI;  0B9E 0BBF
-TAMIL SYLLABLE NYII; 0B9E 0BC0
-TAMIL SYLLABLE NYU;  0B9E 0BC1
-TAMIL SYLLABLE NYUU; 0B9E 0BC2
-TAMIL SYLLABLE NYE;  0B9E 0BC6
-TAMIL SYLLABLE NYEE; 0B9E 0BC7
-TAMIL SYLLABLE NYAI; 0B9E 0BC8
-TAMIL SYLLABLE NYO;  0B9E 0BCA
-TAMIL SYLLABLE NYOO; 0B9E 0BCB
-TAMIL SYLLABLE NYAU; 0B9E 0BCC
-TAMIL SYLLABLE TTAA; 0B9F 0BBE
-TAMIL SYLLABLE TTI;  0B9F 0BBF
-TAMIL SYLLABLE TTII; 0B9F 0BC0
-TAMIL SYLLABLE TTU;  0B9F 0BC1
-TAMIL SYLLABLE TTUU; 0B9F 0BC2
-TAMIL SYLLABLE TTE;  0B9F 0BC6
-TAMIL SYLLABLE TTEE; 0B9F 0BC7
-TAMIL SYLLABLE TTAI; 0B9F 0BC8
-TAMIL SYLLABLE TTO;  0B9F 0BCA
-TAMIL SYLLABLE TTOO; 0B9F 0BCB
-TAMIL SYLLABLE TTAU; 0B9F 0BCC
-TAMIL SYLLABLE NNAA; 0BA3 0BBE
-TAMIL SYLLABLE NNI;  0BA3 0BBF
-TAMIL SYLLABLE NNII; 0BA3 0BC0
-TAMIL SYLLABLE NNU;  0BA3 0BC1
-TAMIL SYLLABLE NNUU; 0BA3 0BC2
-TAMIL SYLLABLE NNE;  0BA3 0BC6
-TAMIL SYLLABLE NNEE; 0BA3 0BC7
-TAMIL SYLLABLE NNAI; 0BA3 0BC8
-TAMIL SYLLABLE NNO;  0BA3 0BCA
-TAMIL SYLLABLE NNOO; 0BA3 0BCB
-TAMIL SYLLABLE NNAU; 0BA3 0BCC
-TAMIL SYLLABLE TAA; 0BA4 0BBE
-TAMIL SYLLABLE TI;  0BA4 0BBF
-TAMIL SYLLABLE TII; 0BA4 0BC0
-TAMIL SYLLABLE TU;  0BA4 0BC1
-TAMIL SYLLABLE TUU; 0BA4 0BC2
-TAMIL SYLLABLE TE;  0BA4 0BC6
-TAMIL SYLLABLE TEE; 0BA4 0BC7
-TAMIL SYLLABLE TAI; 0BA4 0BC8
-TAMIL SYLLABLE TO;  0BA4 0BCA
-TAMIL SYLLABLE TOO; 0BA4 0BCB
-TAMIL SYLLABLE TAU; 0BA4 0BCC
-TAMIL SYLLABLE NAA; 0BA8 0BBE
-TAMIL SYLLABLE NI;  0BA8 0BBF
-TAMIL SYLLABLE NII; 0BA8 0BC0
-TAMIL SYLLABLE NU;  0BA8 0BC1
-TAMIL SYLLABLE NUU; 0BA8 0BC2
-TAMIL SYLLABLE NE;  0BA8 0BC6
-TAMIL SYLLABLE NEE; 0BA8 0BC7
-TAMIL SYLLABLE NAI; 0BA8 0BC8
-TAMIL SYLLABLE NO;  0BA8 0BCA
-TAMIL SYLLABLE NOO; 0BA8 0BCB
-TAMIL SYLLABLE NAU; 0BA8 0BCC
-TAMIL SYLLABLE PAA; 0BAA 0BBE
-TAMIL SYLLABLE PI;  0BAA 0BBF
-TAMIL SYLLABLE PII; 0BAA 0BC0
-TAMIL SYLLABLE PU;  0BAA 0BC1
-TAMIL SYLLABLE PUU; 0BAA 0BC2
-TAMIL SYLLABLE PE;  0BAA 0BC6
-TAMIL SYLLABLE PEE; 0BAA 0BC7
-TAMIL SYLLABLE PAI; 0BAA 0BC8
-TAMIL SYLLABLE PO;  0BAA 0BCA
-TAMIL SYLLABLE POO; 0BAA 0BCB
-TAMIL SYLLABLE PAU; 0BAA 0BCC
-TAMIL SYLLABLE MAA; 0BAE 0BBE
-TAMIL SYLLABLE MI;  0BAE 0BBF
-TAMIL SYLLABLE MII; 0BAE 0BC0
-TAMIL SYLLABLE MU;  0BAE 0BC1
-TAMIL SYLLABLE MUU; 0BAE 0BC2
-TAMIL SYLLABLE ME;  0BAE 0BC6
-TAMIL SYLLABLE MEE; 0BAE 0BC7
-TAMIL SYLLABLE MAI; 0BAE 0BC8
-TAMIL SYLLABLE MO;  0BAE 0BCA
-TAMIL SYLLABLE MOO; 0BAE 0BCB
-TAMIL SYLLABLE MAU; 0BAE 0BCC
-TAMIL SYLLABLE YAA; 0BAF 0BBE
-TAMIL SYLLABLE YI;  0BAF 0BBF
-TAMIL SYLLABLE YII; 0BAF 0BC0
-TAMIL SYLLABLE YU;  0BAF 0BC1
-TAMIL SYLLABLE YUU; 0BAF 0BC2
-TAMIL SYLLABLE YE;  0BAF 0BC6
-TAMIL SYLLABLE YEE; 0BAF 0BC7
-TAMIL SYLLABLE YAI; 0BAF 0BC8
-TAMIL SYLLABLE YO;  0BAF 0BCA
-TAMIL SYLLABLE YOO; 0BAF 0BCB
-TAMIL SYLLABLE YAU; 0BAF 0BCC
-TAMIL SYLLABLE RAA; 0BB0 0BBE
-TAMIL SYLLABLE RI;  0BB0 0BBF
-TAMIL SYLLABLE RII; 0BB0 0BC0
-TAMIL SYLLABLE RU;  0BB0 0BC1
-TAMIL SYLLABLE RUU; 0BB0 0BC2
-TAMIL SYLLABLE RE;  0BB0 0BC6
-TAMIL SYLLABLE REE; 0BB0 0BC7
-TAMIL SYLLABLE RAI; 0BB0 0BC8
-TAMIL SYLLABLE RO;  0BB0 0BCA
-TAMIL SYLLABLE ROO; 0BB0 0BCB
-TAMIL SYLLABLE RAU; 0BB0 0BCC
-TAMIL SYLLABLE LAA; 0BB2 0BBE
-TAMIL SYLLABLE LI;  0BB2 0BBF
-TAMIL SYLLABLE LII; 0BB2 0BC0
-TAMIL SYLLABLE LU;  0BB2 0BC1
-TAMIL SYLLABLE LUU; 0BB2 0BC2
-TAMIL SYLLABLE LE;  0BB2 0BC6
-TAMIL SYLLABLE LEE; 0BB2 0BC7
-TAMIL SYLLABLE LAI; 0BB2 0BC8
-TAMIL SYLLABLE LO;  0BB2 0BCA
-TAMIL SYLLABLE LOO; 0BB2 0BCB
-TAMIL SYLLABLE LAU; 0BB2 0BCC
-TAMIL SYLLABLE VAA; 0BB5 0BBE
-TAMIL SYLLABLE VI;  0BB5 0BBF
-TAMIL SYLLABLE VII; 0BB5 0BC0
-TAMIL SYLLABLE VU;  0BB5 0BC1
-TAMIL SYLLABLE VUU; 0BB5 0BC2
-TAMIL SYLLABLE VE;  0BB5 0BC6
-TAMIL SYLLABLE VEE; 0BB5 0BC7
-TAMIL SYLLABLE VAI; 0BB5 0BC8
-TAMIL SYLLABLE VO;  0BB5 0BCA
-TAMIL SYLLABLE VOO; 0BB5 0BCB
-TAMIL SYLLABLE VAU; 0BB5 0BCC
-TAMIL SYLLABLE LLLAA; 0BB4 0BBE
-TAMIL SYLLABLE LLLI;  0BB4 0BBF
-TAMIL SYLLABLE LLLII; 0BB4 0BC0
-TAMIL SYLLABLE LLLU;  0BB4 0BC1
-TAMIL SYLLABLE LLLUU; 0BB4 0BC2
-TAMIL SYLLABLE LLLE;  0BB4 0BC6
-TAMIL SYLLABLE LLLEE; 0BB4 0BC7
-TAMIL SYLLABLE LLLAI; 0BB4 0BC8
-TAMIL SYLLABLE LLLO;  0BB4 0BCA
-TAMIL SYLLABLE LLLOO; 0BB4 0BCB
-TAMIL SYLLABLE LLLAU; 0BB4 0BCC
-TAMIL SYLLABLE LLAA; 0BB3 0BBE
-TAMIL SYLLABLE LLI;  0BB3 0BBF
-TAMIL SYLLABLE LLII; 0BB3 0BC0
-TAMIL SYLLABLE LLU;  0BB3 0BC1
-TAMIL SYLLABLE LLUU; 0BB3 0BC2
-TAMIL SYLLABLE LLE;  0BB3 0BC6
-TAMIL SYLLABLE LLEE; 0BB3 0BC7
-TAMIL SYLLABLE LLAI; 0BB3 0BC8
-TAMIL SYLLABLE LLO;  0BB3 0BCA
-TAMIL SYLLABLE LLOO; 0BB3 0BCB
-TAMIL SYLLABLE LLAU; 0BB3 0BCC
-TAMIL SYLLABLE RRAA; 0BB1 0BBE
-TAMIL SYLLABLE RRI;  0BB1 0BBF
-TAMIL SYLLABLE RRII; 0BB1 0BC0
-TAMIL SYLLABLE RRU;  0BB1 0BC1
-TAMIL SYLLABLE RRUU; 0BB1 0BC2
-TAMIL SYLLABLE RRE;  0BB1 0BC6
-TAMIL SYLLABLE RREE; 0BB1 0BC7
-TAMIL SYLLABLE RRAI; 0BB1 0BC8
-TAMIL SYLLABLE RRO;  0BB1 0BCA
-TAMIL SYLLABLE RROO; 0BB1 0BCB
-TAMIL SYLLABLE RRAU; 0BB1 0BCC
-TAMIL SYLLABLE NNNAA; 0BA9 0BBE
-TAMIL SYLLABLE NNNI;  0BA9 0BBF
-TAMIL SYLLABLE NNNII; 0BA9 0BC0
-TAMIL SYLLABLE NNNU;  0BA9 0BC1
-TAMIL SYLLABLE NNNUU; 0BA9 0BC2
-TAMIL SYLLABLE NNNE;  0BA9 0BC6
-TAMIL SYLLABLE NNNEE; 0BA9 0BC7
-TAMIL SYLLABLE NNNAI; 0BA9 0BC8
-TAMIL SYLLABLE NNNO;  0BA9 0BCA
-TAMIL SYLLABLE NNNOO; 0BA9 0BCB
-TAMIL SYLLABLE NNNAU; 0BA9 0BCC
-TAMIL SYLLABLE JAA; 0B9C 0BBE
-TAMIL SYLLABLE JI;  0B9C 0BBF
-TAMIL SYLLABLE JII; 0B9C 0BC0
-TAMIL SYLLABLE JU;  0B9C 0BC1
-TAMIL SYLLABLE JUU; 0B9C 0BC2
-TAMIL SYLLABLE JE;  0B9C 0BC6
-TAMIL SYLLABLE JEE; 0B9C 0BC7
-TAMIL SYLLABLE JAI; 0B9C 0BC8
-TAMIL SYLLABLE JO;  0B9C 0BCA
-TAMIL SYLLABLE JOO; 0B9C 0BCB
-TAMIL SYLLABLE JAU; 0B9C 0BCC
-TAMIL SYLLABLE SHAA; 0BB6 0BBE
-TAMIL SYLLABLE SHI;  0BB6 0BBF
-TAMIL SYLLABLE SHII; 0BB6 0BC0
-TAMIL SYLLABLE SHU;  0BB6 0BC1
-TAMIL SYLLABLE SHUU; 0BB6 0BC2
-TAMIL SYLLABLE SHE;  0BB6 0BC6
-TAMIL SYLLABLE SHEE; 0BB6 0BC7
-TAMIL SYLLABLE SHAI; 0BB6 0BC8
-TAMIL SYLLABLE SHO;  0BB6 0BCA
-TAMIL SYLLABLE SHOO; 0BB6 0BCB
-TAMIL SYLLABLE SHAU; 0BB6 0BCC
-TAMIL SYLLABLE SSAA; 0BB7 0BBE
-TAMIL SYLLABLE SSI;  0BB7 0BBF
-TAMIL SYLLABLE SSII; 0BB7 0BC0
-TAMIL SYLLABLE SSU;  0BB7 0BC1
-TAMIL SYLLABLE SSUU; 0BB7 0BC2
-TAMIL SYLLABLE SSE;  0BB7 0BC6
-TAMIL SYLLABLE SSEE; 0BB7 0BC7
-TAMIL SYLLABLE SSAI; 0BB7 0BC8
-TAMIL SYLLABLE SSO;  0BB7 0BCA
-TAMIL SYLLABLE SSOO; 0BB7 0BCB
-TAMIL SYLLABLE SSAU; 0BB7 0BCC
-TAMIL SYLLABLE SAA; 0BB8 0BBE
-TAMIL SYLLABLE SI;  0BB8 0BBF
-TAMIL SYLLABLE SII; 0BB8 0BC0
-TAMIL SYLLABLE SU;  0BB8 0BC1
-TAMIL SYLLABLE SUU; 0BB8 0BC2
-TAMIL SYLLABLE SE;  0BB8 0BC6
-TAMIL SYLLABLE SEE; 0BB8 0BC7
-TAMIL SYLLABLE SAI; 0BB8 0BC8
-TAMIL SYLLABLE SO;  0BB8 0BCA
-TAMIL SYLLABLE SOO; 0BB8 0BCB
-TAMIL SYLLABLE SAU; 0BB8 0BCC
-TAMIL SYLLABLE HAA; 0BB9 0BBE
-TAMIL SYLLABLE HI;  0BB9 0BBF
-TAMIL SYLLABLE HII; 0BB9 0BC0
-TAMIL SYLLABLE HU;  0BB9 0BC1
-TAMIL SYLLABLE HUU; 0BB9 0BC2
-TAMIL SYLLABLE HE;  0BB9 0BC6
-TAMIL SYLLABLE HEE; 0BB9 0BC7
-TAMIL SYLLABLE HAI; 0BB9 0BC8
-TAMIL SYLLABLE HO;  0BB9 0BCA
-TAMIL SYLLABLE HOO; 0BB9 0BCB
-TAMIL SYLLABLE HAU; 0BB9 0BCC
-TAMIL SYLLABLE KSSA;  0B95 0BCD 0BB7
-TAMIL SYLLABLE KSSAA; 0B95 0BCD 0BB7 0BBE
-TAMIL SYLLABLE KSSI;  0B95 0BCD 0BB7 0BBF
-TAMIL SYLLABLE KSSII; 0B95 0BCD 0BB7 0BC0
-TAMIL SYLLABLE KSSU;  0B95 0BCD 0BB7 0BC1
-TAMIL SYLLABLE KSSUU; 0B95 0BCD 0BB7 0BC2
-TAMIL SYLLABLE KSSE;  0B95 0BCD 0BB7 0BC6
-TAMIL SYLLABLE KSSEE; 0B95 0BCD 0BB7 0BC7
-TAMIL SYLLABLE KSSAI; 0B95 0BCD 0BB7 0BC8
-TAMIL SYLLABLE KSSO;  0B95 0BCD 0BB7 0BCA
-TAMIL SYLLABLE KSSOO; 0B95 0BCD 0BB7 0BCB
-TAMIL SYLLABLE KSSAU; 0B95 0BCD 0BB7 0BCC
-TAMIL SYLLABLE SHRII; 0BB6 0BCD 0BB0 0BC0
-SINHALA CONSONANT SIGN YANSAYA;0DCA 200D 0DBA
-SINHALA CONSONANT SIGN RAKAARAANSAYA;0DCA 200D 0DBB
-SINHALA CONSONANT SIGN REPAYA;0DBB 0DCA 200D
-GEORGIAN LETTER U-BRJGU;10E3 0302
-KHMER CONSONANT SIGN COENG KA;17D2 1780
-KHMER CONSONANT SIGN COENG KHA;17D2 1781
-KHMER CONSONANT SIGN COENG KO;17D2 1782
-KHMER CONSONANT SIGN COENG KHO;17D2 1783
-KHMER CONSONANT SIGN COENG NGO;17D2 1784
-KHMER CONSONANT SIGN COENG CA;17D2 1785
-KHMER CONSONANT SIGN COENG CHA;17D2 1786
-KHMER CONSONANT SIGN COENG CO;17D2 1787
-KHMER CONSONANT SIGN COENG CHO;17D2 1788
-KHMER CONSONANT SIGN COENG NYO;17D2 1789
-KHMER CONSONANT SIGN COENG DA;17D2 178A
-KHMER CONSONANT SIGN COENG TTHA;17D2 178B
-KHMER CONSONANT SIGN COENG DO;17D2 178C
-KHMER CONSONANT SIGN COENG TTHO;17D2 178D
-KHMER CONSONANT SIGN COENG NA;17D2 178E
-KHMER CONSONANT SIGN COENG TA;17D2 178F
-KHMER CONSONANT SIGN COENG THA;17D2 1790
-KHMER CONSONANT SIGN COENG TO;17D2 1791
-KHMER CONSONANT SIGN COENG THO;17D2 1792
-KHMER CONSONANT SIGN COENG NO;17D2 1793
-KHMER CONSONANT SIGN COENG BA;17D2 1794
-KHMER CONSONANT SIGN COENG PHA;17D2 1795
-KHMER CONSONANT SIGN COENG PO;17D2 1796
-KHMER CONSONANT SIGN COENG PHO;17D2 1797
-KHMER CONSONANT SIGN COENG MO;17D2 1798
-KHMER CONSONANT SIGN COENG YO;17D2 1799
-KHMER CONSONANT SIGN COENG RO;17D2 179A
-KHMER CONSONANT SIGN COENG LO;17D2 179B
-KHMER CONSONANT SIGN COENG VO;17D2 179C
-KHMER CONSONANT SIGN COENG SHA;17D2 179D
-KHMER CONSONANT SIGN COENG SSA;17D2 179E
-KHMER CONSONANT SIGN COENG SA;17D2 179F
-KHMER CONSONANT SIGN COENG HA;17D2 17A0
-KHMER CONSONANT SIGN COENG LA;17D2 17A1
-KHMER VOWEL SIGN COENG QA;17D2 17A2
-KHMER INDEPENDENT VOWEL SIGN COENG QU;17D2 17A7
-KHMER INDEPENDENT VOWEL SIGN COENG RY;17D2 17AB
-KHMER INDEPENDENT VOWEL SIGN COENG RYY;17D2 17AC
-KHMER INDEPENDENT VOWEL SIGN COENG QE;17D2 17AF
-KHMER VOWEL SIGN OM;17BB 17C6
-KHMER VOWEL SIGN AAM;17B6 17C6
-HIRAGANA LETTER BIDAKUON NGA;304B 309A
-HIRAGANA LETTER BIDAKUON NGI;304D 309A
-HIRAGANA LETTER BIDAKUON NGU;304F 309A
-HIRAGANA LETTER BIDAKUON NGE;3051 309A
-HIRAGANA LETTER BIDAKUON NGO;3053 309A
-KATAKANA LETTER BIDAKUON NGA;30AB 309A
-KATAKANA LETTER BIDAKUON NGI;30AD 309A
-KATAKANA LETTER BIDAKUON NGU;30AF 309A
-KATAKANA LETTER BIDAKUON NGE;30B1 309A
-KATAKANA LETTER BIDAKUON NGO;30B3 309A
-KATAKANA LETTER AINU CE;30BB 309A
-KATAKANA LETTER AINU TU;30C4 309A
-KATAKANA LETTER AINU TO;30C8 309A
-KATAKANA LETTER AINU P;31F7 309A
-MODIFIER LETTER EXTRA-HIGH EXTRA-LOW CONTOUR TONE BAR;02E5 02E9
-MODIFIER LETTER EXTRA-LOW EXTRA-HIGH CONTOUR TONE BAR;02E9 02E5
@@ -1,103 +0,0 @@
-00DF; 00DF; 0053 0073; 0053 0053; # LATIN SMALL LETTER SHARP S
-0130; 0069 0307; 0130; 0130; # LATIN CAPITAL LETTER I WITH DOT ABOVE
-FB00; FB00; 0046 0066; 0046 0046; # LATIN SMALL LIGATURE FF
-FB01; FB01; 0046 0069; 0046 0049; # LATIN SMALL LIGATURE FI
-FB02; FB02; 0046 006C; 0046 004C; # LATIN SMALL LIGATURE FL
-FB03; FB03; 0046 0066 0069; 0046 0046 0049; # LATIN SMALL LIGATURE FFI
-FB04; FB04; 0046 0066 006C; 0046 0046 004C; # LATIN SMALL LIGATURE FFL
-FB05; FB05; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE LONG S T
-FB06; FB06; 0053 0074; 0053 0054; # LATIN SMALL LIGATURE ST
-0587; 0587; 0535 0582; 0535 0552; # ARMENIAN SMALL LIGATURE ECH YIWN
-FB13; FB13; 0544 0576; 0544 0546; # ARMENIAN SMALL LIGATURE MEN NOW
-FB14; FB14; 0544 0565; 0544 0535; # ARMENIAN SMALL LIGATURE MEN ECH
-FB15; FB15; 0544 056B; 0544 053B; # ARMENIAN SMALL LIGATURE MEN INI
-FB16; FB16; 054E 0576; 054E 0546; # ARMENIAN SMALL LIGATURE VEW NOW
-FB17; FB17; 0544 056D; 0544 053D; # ARMENIAN SMALL LIGATURE MEN XEH
-0149; 0149; 02BC 004E; 02BC 004E; # LATIN SMALL LETTER N PRECEDED BY APOSTROPHE
-0390; 0390; 0399 0308 0301; 0399 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS
-03B0; 03B0; 03A5 0308 0301; 03A5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS
-01F0; 01F0; 004A 030C; 004A 030C; # LATIN SMALL LETTER J WITH CARON
-1E96; 1E96; 0048 0331; 0048 0331; # LATIN SMALL LETTER H WITH LINE BELOW
-1E97; 1E97; 0054 0308; 0054 0308; # LATIN SMALL LETTER T WITH DIAERESIS
-1E98; 1E98; 0057 030A; 0057 030A; # LATIN SMALL LETTER W WITH RING ABOVE
-1E99; 1E99; 0059 030A; 0059 030A; # LATIN SMALL LETTER Y WITH RING ABOVE
-1E9A; 1E9A; 0041 02BE; 0041 02BE; # LATIN SMALL LETTER A WITH RIGHT HALF RING
-1F50; 1F50; 03A5 0313; 03A5 0313; # GREEK SMALL LETTER UPSILON WITH PSILI
-1F52; 1F52; 03A5 0313 0300; 03A5 0313 0300; # GREEK SMALL LETTER UPSILON WITH PSILI AND VARIA
-1F54; 1F54; 03A5 0313 0301; 03A5 0313 0301; # GREEK SMALL LETTER UPSILON WITH PSILI AND OXIA
-1F56; 1F56; 03A5 0313 0342; 03A5 0313 0342; # GREEK SMALL LETTER UPSILON WITH PSILI AND PERISPOMENI
-1FB6; 1FB6; 0391 0342; 0391 0342; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI
-1FC6; 1FC6; 0397 0342; 0397 0342; # GREEK SMALL LETTER ETA WITH PERISPOMENI
-1FD2; 1FD2; 0399 0308 0300; 0399 0308 0300; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND VARIA
-1FD3; 1FD3; 0399 0308 0301; 0399 0308 0301; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND OXIA
-1FD6; 1FD6; 0399 0342; 0399 0342; # GREEK SMALL LETTER IOTA WITH PERISPOMENI
-1FD7; 1FD7; 0399 0308 0342; 0399 0308 0342; # GREEK SMALL LETTER IOTA WITH DIALYTIKA AND PERISPOMENI
-1FE2; 1FE2; 03A5 0308 0300; 03A5 0308 0300; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND VARIA
-1FE3; 1FE3; 03A5 0308 0301; 03A5 0308 0301; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND OXIA
-1FE4; 1FE4; 03A1 0313; 03A1 0313; # GREEK SMALL LETTER RHO WITH PSILI
-1FE6; 1FE6; 03A5 0342; 03A5 0342; # GREEK SMALL LETTER UPSILON WITH PERISPOMENI
-1FE7; 1FE7; 03A5 0308 0342; 03A5 0308 0342; # GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND PERISPOMENI
-1FF6; 1FF6; 03A9 0342; 03A9 0342; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI
-1F80; 1F80; 1F88; 1F08 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND YPOGEGRAMMENI
-1F81; 1F81; 1F89; 1F09 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND YPOGEGRAMMENI
-1F82; 1F82; 1F8A; 1F0A 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND VARIA AND YPOGEGRAMMENI
-1F83; 1F83; 1F8B; 1F0B 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND VARIA AND YPOGEGRAMMENI
-1F84; 1F84; 1F8C; 1F0C 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND OXIA AND YPOGEGRAMMENI
-1F85; 1F85; 1F8D; 1F0D 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND OXIA AND YPOGEGRAMMENI
-1F86; 1F86; 1F8E; 1F0E 0399; # GREEK SMALL LETTER ALPHA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
-1F87; 1F87; 1F8F; 1F0F 0399; # GREEK SMALL LETTER ALPHA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
-1F88; 1F80; 1F88; 1F08 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PROSGEGRAMMENI
-1F89; 1F81; 1F89; 1F09 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PROSGEGRAMMENI
-1F8A; 1F82; 1F8A; 1F0A 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND VARIA AND PROSGEGRAMMENI
-1F8B; 1F83; 1F8B; 1F0B 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND VARIA AND PROSGEGRAMMENI
-1F8C; 1F84; 1F8C; 1F0C 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND OXIA AND PROSGEGRAMMENI
-1F8D; 1F85; 1F8D; 1F0D 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND OXIA AND PROSGEGRAMMENI
-1F8E; 1F86; 1F8E; 1F0E 0399; # GREEK CAPITAL LETTER ALPHA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
-1F8F; 1F87; 1F8F; 1F0F 0399; # GREEK CAPITAL LETTER ALPHA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
-1F90; 1F90; 1F98; 1F28 0399; # GREEK SMALL LETTER ETA WITH PSILI AND YPOGEGRAMMENI
-1F91; 1F91; 1F99; 1F29 0399; # GREEK SMALL LETTER ETA WITH DASIA AND YPOGEGRAMMENI
-1F92; 1F92; 1F9A; 1F2A 0399; # GREEK SMALL LETTER ETA WITH PSILI AND VARIA AND YPOGEGRAMMENI
-1F93; 1F93; 1F9B; 1F2B 0399; # GREEK SMALL LETTER ETA WITH DASIA AND VARIA AND YPOGEGRAMMENI
-1F94; 1F94; 1F9C; 1F2C 0399; # GREEK SMALL LETTER ETA WITH PSILI AND OXIA AND YPOGEGRAMMENI
-1F95; 1F95; 1F9D; 1F2D 0399; # GREEK SMALL LETTER ETA WITH DASIA AND OXIA AND YPOGEGRAMMENI
-1F96; 1F96; 1F9E; 1F2E 0399; # GREEK SMALL LETTER ETA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
-1F97; 1F97; 1F9F; 1F2F 0399; # GREEK SMALL LETTER ETA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
-1F98; 1F90; 1F98; 1F28 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND PROSGEGRAMMENI
-1F99; 1F91; 1F99; 1F29 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND PROSGEGRAMMENI
-1F9A; 1F92; 1F9A; 1F2A 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND VARIA AND PROSGEGRAMMENI
-1F9B; 1F93; 1F9B; 1F2B 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND VARIA AND PROSGEGRAMMENI
-1F9C; 1F94; 1F9C; 1F2C 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND OXIA AND PROSGEGRAMMENI
-1F9D; 1F95; 1F9D; 1F2D 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND OXIA AND PROSGEGRAMMENI
-1F9E; 1F96; 1F9E; 1F2E 0399; # GREEK CAPITAL LETTER ETA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
-1F9F; 1F97; 1F9F; 1F2F 0399; # GREEK CAPITAL LETTER ETA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
-1FA0; 1FA0; 1FA8; 1F68 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND YPOGEGRAMMENI
-1FA1; 1FA1; 1FA9; 1F69 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND YPOGEGRAMMENI
-1FA2; 1FA2; 1FAA; 1F6A 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND VARIA AND YPOGEGRAMMENI
-1FA3; 1FA3; 1FAB; 1F6B 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND VARIA AND YPOGEGRAMMENI
-1FA4; 1FA4; 1FAC; 1F6C 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND OXIA AND YPOGEGRAMMENI
-1FA5; 1FA5; 1FAD; 1F6D 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND OXIA AND YPOGEGRAMMENI
-1FA6; 1FA6; 1FAE; 1F6E 0399; # GREEK SMALL LETTER OMEGA WITH PSILI AND PERISPOMENI AND YPOGEGRAMMENI
-1FA7; 1FA7; 1FAF; 1F6F 0399; # GREEK SMALL LETTER OMEGA WITH DASIA AND PERISPOMENI AND YPOGEGRAMMENI
-1FA8; 1FA0; 1FA8; 1F68 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PROSGEGRAMMENI
-1FA9; 1FA1; 1FA9; 1F69 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PROSGEGRAMMENI
-1FAA; 1FA2; 1FAA; 1F6A 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND VARIA AND PROSGEGRAMMENI
-1FAB; 1FA3; 1FAB; 1F6B 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND VARIA AND PROSGEGRAMMENI
-1FAC; 1FA4; 1FAC; 1F6C 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND OXIA AND PROSGEGRAMMENI
-1FAD; 1FA5; 1FAD; 1F6D 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND OXIA AND PROSGEGRAMMENI
-1FAE; 1FA6; 1FAE; 1F6E 0399; # GREEK CAPITAL LETTER OMEGA WITH PSILI AND PERISPOMENI AND PROSGEGRAMMENI
-1FAF; 1FA7; 1FAF; 1F6F 0399; # GREEK CAPITAL LETTER OMEGA WITH DASIA AND PERISPOMENI AND PROSGEGRAMMENI
-1FB3; 1FB3; 1FBC; 0391 0399; # GREEK SMALL LETTER ALPHA WITH YPOGEGRAMMENI
-1FBC; 1FB3; 1FBC; 0391 0399; # GREEK CAPITAL LETTER ALPHA WITH PROSGEGRAMMENI
-1FC3; 1FC3; 1FCC; 0397 0399; # GREEK SMALL LETTER ETA WITH YPOGEGRAMMENI
-1FCC; 1FC3; 1FCC; 0397 0399; # GREEK CAPITAL LETTER ETA WITH PROSGEGRAMMENI
-1FF3; 1FF3; 1FFC; 03A9 0399; # GREEK SMALL LETTER OMEGA WITH YPOGEGRAMMENI
-1FFC; 1FF3; 1FFC; 03A9 0399; # GREEK CAPITAL LETTER OMEGA WITH PROSGEGRAMMENI
-1FB2; 1FB2; 1FBA 0345; 1FBA 0399; # GREEK SMALL LETTER ALPHA WITH VARIA AND YPOGEGRAMMENI
-1FB4; 1FB4; 0386 0345; 0386 0399; # GREEK SMALL LETTER ALPHA WITH OXIA AND YPOGEGRAMMENI
-1FC2; 1FC2; 1FCA 0345; 1FCA 0399; # GREEK SMALL LETTER ETA WITH VARIA AND YPOGEGRAMMENI
-1FC4; 1FC4; 0389 0345; 0389 0399; # GREEK SMALL LETTER ETA WITH OXIA AND YPOGEGRAMMENI
-1FF2; 1FF2; 1FFA 0345; 1FFA 0399; # GREEK SMALL LETTER OMEGA WITH VARIA AND YPOGEGRAMMENI
-1FF4; 1FF4; 038F 0345; 038F 0399; # GREEK SMALL LETTER OMEGA WITH OXIA AND YPOGEGRAMMENI
-1FB7; 1FB7; 0391 0342 0345; 0391 0342 0399; # GREEK SMALL LETTER ALPHA WITH PERISPOMENI AND YPOGEGRAMMENI
-1FC7; 1FC7; 0397 0342 0345; 0397 0342 0399; # GREEK SMALL LETTER ETA WITH PERISPOMENI AND YPOGEGRAMMENI
-1FF7; 1FF7; 03A9 0342 0345; 03A9 0342 0399; # GREEK SMALL LETTER OMEGA WITH PERISPOMENI AND YPOGEGRAMMENI
@@ -1,224 +0,0 @@
-# This file has its own compilation step because
-# it needs to parse String.Unicode data and
-# compile a digested module.
-defmodule String.Unicode do
-  @moduledoc false
-
-  def version, do: {6,2,0}
-
-  to_binary = fn
-    "" ->
-      nil
-    codepoints ->
-      codepoints = :binary.split(codepoints, " ", [:global])
-      Enum.reduce codepoints, "", fn(codepoint, acc) ->
-        acc <> << binary_to_integer(codepoint, 16) :: utf8 >>
-      end
-  end
-
-  data_path = Path.join(__DIR__, "UnicodeData.txt")
-
-  { codes, whitespace } = Enum.reduce File.iterator!(data_path), { [], [] }, fn(line, { cacc, wacc }) ->
-    [ codepoint, _name, _category,
-      _class, bidi, _decomposition,
-      _numeric_1, _numeric_2, _numeric_3,
-      _bidi_mirror, _unicode_1, _iso,
-      upper, lower, title ] = :binary.split(line, ";", [:global])
-
-    title = :binary.part(title, 0, size(title) - 1)
-
-    cond do
-      upper != "" or lower != "" or title != "" ->
-        { [{ to_binary.(codepoint), to_binary.(upper), to_binary.(lower), to_binary.(title) } | cacc], wacc }
-      bidi in ["B", "S", "WS"] ->
-        { cacc, [to_binary.(codepoint) | wacc] }
-      true ->
-        { cacc, wacc }
-    end
-  end
-
-  special_path = Path.join(__DIR__, "SpecialCasing.txt")
-
-  codes = Enum.reduce File.iterator!(special_path), codes, fn(line, acc) ->
-    [ codepoint, lower, title, upper, _comment ] = :binary.split(line, "; ", [:global])
-    key = to_binary.(codepoint)
-    :lists.keystore(key, 1, acc, { key, to_binary.(upper), to_binary.(lower), to_binary.(title) })
-  end
-
-  seqs_path = Path.join(__DIR__, "NamedSequences.txt")
-
-  seqs = Enum.map File.iterator!(seqs_path), fn(line) ->
-    [ _name, codepoints ] = :binary.split(line, ";", [:global])
-    codepoints = :binary.split(codepoints, " ", [:global])
-    codepoints = Enum.map codepoints, Regex.replace(%r/\s+/, &1, "")
-    codepoints = Enum.filter codepoints, fn(x) -> size(x) > 0 end
-    Enum.map codepoints, to_binary.(&1)
-  end
-
-  # Downcase
-
-  def downcase(string), do: do_downcase(string) |> list_to_binary
-
-  lc { codepoint, _upper, lower, _title } inlist codes, lower && lower != codepoint do
-    defp do_downcase(unquote(codepoint) <> rest) do
-      unquote(binary_to_list(lower)) ++ downcase(rest)
-    end
-  end
-
-  defp do_downcase(<< char, rest :: binary >>) do
-    [char|do_downcase(rest)]
-  end
-
-  defp do_downcase(""), do: []
-
-  # Upcase
-
-  def upcase(string), do: do_upcase(string) |> list_to_binary
-
-  lc { codepoint, upper, _lower, _title } inlist codes, upper && upper != codepoint do
-    defp do_upcase(unquote(codepoint) <> rest) do
-      unquote(binary_to_list(upper)) ++ do_upcase(rest)
-    end
-  end
-
-  defp do_upcase(<< char, rest :: binary >>) do
-    [char|do_upcase(rest)]
-  end
-
-  defp do_upcase(""), do: []
-
-  # Titlecase once
-
-  def titlecase_once(""), do: { "", "" }
-
-  lc { codepoint, _upper, _lower, title } inlist codes, title && title != codepoint do
-    def titlecase_once(unquote(codepoint) <> rest) do
-      { unquote(title), rest }
-    end
-  end
-
-  def titlecase_once(<< char, rest :: binary >>) do
-    { << char >>, rest }
-  end
-
-  # Strip
-
-  def lstrip(""), do: ""
-
-  lc codepoint inlist whitespace do
-    def lstrip(unquote(codepoint) <> rest) do
-      lstrip(rest)
-    end
-  end
-
-  def lstrip(other) when is_binary(other), do: other
-
-  def rstrip(string) when is_binary(string) do
-    do_rstrip(string, [], [])
-  end
-
-  lc codepoint inlist whitespace do
-    c = binary_to_list(codepoint) |> :lists.reverse
-
-    defp do_rstrip(unquote(codepoint) <> rest, acc1, acc2) do
-      do_rstrip(rest, unquote(c) ++ (acc1 || acc2), acc2)
-    end
-  end
-
-  defp do_rstrip(<< char, rest :: binary >>, nil, acc2) do
-    do_rstrip(rest, nil, [char|acc2])
-  end
-
-  defp do_rstrip(<< char, rest :: binary >>, acc1, _acc2) do
-    do_rstrip(rest, nil, [char|acc1])
-  end
-
-  defp do_rstrip(<<>>, _acc1, acc2), do: acc2 |> :lists.reverse |> list_to_binary
-
-  # Split
-
-  def split(""), do: ""
-
-  def split(string) when is_binary(string) do
-    :lists.reverse do_split(string, "", [])
-  end
-
-  lc codepoint inlist whitespace do
-    defp do_split(unquote(codepoint) <> rest, buffer, acc) do
-      if buffer != "" do
-        do_split(rest, "", [buffer | acc])
-      else
-        do_split(rest, buffer, acc)
-      end
-    end
-  end
-
-  defp do_split(<< char, rest :: binary >>, buffer, acc) do
-    do_split(rest, << buffer :: binary, char >>, acc)
-  end
-
-  defp do_split(<<>>, buffer, acc) do
-    if buffer != "" do
-      [buffer | acc]
-    else
-      acc
-    end
-  end
-
-  # Graphemes
-
-  lc codepoints inlist seqs do
-    def next_grapheme(<< unquote_splicing(codepoints), t :: binary >>) do
-      { << unquote_splicing(codepoints) >>, t }
-    end
-  end
-
-  def next_grapheme(<<>>) do
-    :no_grapheme
-  end
-
-  def next_grapheme(binary) when is_binary(binary) do
-    case next_codepoint(binary) do
-      :no_codepoint -> :no_grapheme
-      other -> other
-    end
-  end
-
-  def graphemes(binary) when is_binary(binary) do
-    do_graphemes(next_grapheme(binary))
-  end
-
-  defp do_graphemes({ c, rest }) do
-    [c|do_graphemes(next_grapheme(rest))]
-  end
-
-  defp do_graphemes(:no_grapheme) do
-    []
-  end
-
-  # Codepoints
-
-  def next_codepoint(<< cp :: utf8, rest :: binary >>) do
-    { <<cp :: utf8>>, rest }
-  end
-
-  def next_codepoint(<< cp, rest :: binary >>) do
-    { <<cp>>, rest }
-  end
-
-  def next_codepoint(<<>>) do
-    :no_codepoint
-  end
-
-  def codepoints(binary) when is_binary(binary) do
-    do_codepoints(next_codepoint(binary))
-  end
-
-  defp do_codepoints({ c, rest }) do
-    [c|do_codepoints(next_codepoint(rest))]
-  end
-
-  defp do_codepoints(:no_codepoint) do
-    []
-  end
-end
@@ -1,27 +0,0 @@
-{erl_first_files, ["elixir_transform"]}.
-
-{erl_opts, [
-            warn_unused_vars,
-            warn_export_all,
-            warn_shadow_vars,
-            warn_unused_import,
-            warn_unused_function,
-            warn_bif_clash,
-            warn_unused_record,
-            warn_deprecated_function,
-            warn_obsolete_guard,
-            strict_validation,
-            warn_exported_vars,
-            %% warn_export_vars,
-            %% warn_missing_spec,
-            %% warn_untyped_record,
-            %% warnings_as_errors,
-            debug_info
-           ]}.
-
-{yrl_opts, [
-            {report, true},
-            {verbose, false}
-           ]}.
-
-{require_otp_vsn,"(R16).*"}.
@@ -1,175 +0,0 @@
-module(elixir).
-behaviour(application).
-export([main/1, start_cli/0,
-  scope_for_eval/1, scope_for_eval/2,
-  eval/2, eval/3, eval/4,
-  eval_quoted/2, eval_quoted/3, eval_quoted/4,
-  eval_forms/3, translate_forms/3]).
-include("elixir.hrl").
-
-%% Top level types
-export_type([char_list/0, as_boolean/1]).
-type char_list() :: string().
-type as_boolean(T) :: T.
-
-% OTP APPLICATION API
-
-export([start/2, stop/1, config_change/3]).
-
-start(_Type, _Args) ->
-  %% Set the shell to unicode so printing inside scripts work
-  %% Those can take a while, so let's do it in a new process
-  spawn(fun() ->
-    io:setopts(standard_io, [binary,{encoding,unicode}]),
-    io:setopts(standard_error, [binary,{encoding,unicode}])
-  end),
-  elixir_sup:start_link([]).
-
-stop(_S) ->
-  ok.
-
-config_change(_Changed, _New, _Remove) ->
-  ok.
-
-%% escript entry point
-
-main(Args) ->
-  application:start(?MODULE),
-  'Elixir.Kernel.CLI':main(Args).
-
-%% Boot and process given options. Invoked by Elixir's script.
-
-start_cli() ->
-  application:start(?MODULE),
-  'Elixir.Kernel.CLI':main(init:get_plain_arguments()).
-
-%% EVAL HOOKS
-
-scope_for_eval(Opts) ->
-  scope_for_eval(#elixir_scope{
-    file = <<"nofile">>,
-    local = nil,
-    aliases = [],
-    requires = elixir_dispatch:default_requires(),
-    functions = elixir_dispatch:default_functions(),
-    macros = elixir_dispatch:default_macros()
-  }, Opts).
-
-scope_for_eval(Scope, Opts) ->
-  File = case lists:keyfind(file, 1, Opts) of
-    { file, RawFile } -> to_binary(RawFile);
-    false -> Scope#elixir_scope.file
-  end,
-
-  Local = case lists:keyfind(delegate_locals_to, 1, Opts) of
-    { delegate_locals_to, LocalOpt } -> LocalOpt;
-    false -> Scope#elixir_scope.local
-  end,
-
-  Aliases = case lists:keyfind(aliases, 1, Opts) of
-    { aliases, AliasesOpt } -> AliasesOpt;
-    false -> Scope#elixir_scope.aliases
-  end,
-
-  Requires = case lists:keyfind(requires, 1, Opts) of
-    { requires, List } -> ordsets:from_list(List);
-    false -> Scope#elixir_scope.requires
-  end,
-
-  Functions = case lists:keyfind(functions, 1, Opts) of
-    { functions, FunctionsOpt } -> FunctionsOpt;
-    false -> Scope#elixir_scope.functions
-  end,
-
-  Macros = case lists:keyfind(macros, 1, Opts) of
-    { macros, MacrosOpt } -> MacrosOpt;
-    false -> Scope#elixir_scope.macros
-  end,
-
-  Scope#elixir_scope{
-    file=File, local=Local,
-    macros=Macros, functions=Functions,
-    requires=Requires, aliases=Aliases }.
-
-%% String evaluation
-
-eval(String, Binding) -> eval(String, Binding, []).
-
-eval(String, Binding, Opts) ->
-  case lists:keyfind(line, 1, Opts) of
-    false -> Line = 1;
-    { line, Line } -> []
-  end,
-  eval(String, Binding, Line, scope_for_eval(Opts)).
-
-eval(String, Binding, Line, #elixir_scope{file=File} = S) when
-    is_list(String), is_list(Binding), is_integer(Line), is_binary(File) ->
-  Forms = elixir_translator:'forms!'(String, Line, File, []),
-  eval_forms(Forms, Binding, S).
-
-%% Quoted evaluation
-
-eval_quoted(Tree, Binding) -> eval_quoted(Tree, Binding, []).
-
-eval_quoted(Tree, Binding, Opts) ->
-  case lists:keyfind(line, 1, Opts) of
-    { line, Line } -> [];
-    false -> Line = 1
-  end,
-  eval_quoted(Tree, Binding, Line, scope_for_eval(Opts)).
-
-eval_quoted(Tree, Binding, Line, #elixir_scope{} = S) when is_integer(Line) ->
-  eval_forms(elixir_quote:linify(Line, Tree), Binding, S).
-
-%% Handle forms evaluation internally, it is an
-%% internal API not meant for external usage.
-
-translate_forms(Tree, Binding, Opts) when is_list(Opts) ->
-  translate_forms(Tree, Binding, scope_for_eval(Opts));
-
-translate_forms(Tree, Binding, #elixir_scope{} = Scope) ->
-  elixir_translator:translate(Tree, Scope#elixir_scope{
-    vars=binding_dict(Binding),
-    temp_vars=[],
-    clause_vars=nil,
-    counter=[]
-  }).
-
-eval_forms(Tree, Binding, Scope) ->
-  { ParseTree, NewScope } = translate_forms(Tree, Binding, Scope),
-  case ParseTree of
-    [] -> { nil, Binding, NewScope };
-    _  ->
-      {value, Value, NewBinding} = erl_eval:exprs(ParseTree, normalize_binding(Binding)),
-      {Value, final_binding(NewBinding, NewScope#elixir_scope.vars), NewScope }
-  end.
-
-%% INTERNAL HELPERS
-
-to_binary(Bin)  when is_binary(Bin) -> Bin;
-to_binary(List) when is_list(List) -> list_to_binary(List).
-
-binding_dict(List) -> binding_dict(List, orddict:new()).
-binding_dict([{{H,Kind},_}|T], Dict) -> binding_dict(T, orddict:store({ H, Kind }, H, Dict));
-binding_dict([{H,_}|T], Dict) -> binding_dict(T, orddict:store({ H, nil }, H, Dict));
-binding_dict([], Dict) -> Dict.
-
-final_binding(Binding, Vars) -> final_binding(Binding, [], Binding, Vars).
-final_binding([{Var,_}|T], Acc, Binding, Vars) ->
-  case lists:member($@, atom_to_list(Var)) of
-    true  ->
-      final_binding(T, Acc, Binding, Vars);
-    false ->
-      RealName  = orddict:fetch({ Var, nil }, Vars),
-      RealValue = proplists:get_value(RealName, Binding, nil),
-      final_binding(T, [{Var, RealValue}|Acc], Binding, Vars)
-  end;
-
-final_binding([], Acc, _Binding, _Vars) -> lists:reverse(Acc).
-
-normalize_binding(Binding) ->
-  Keyword = orddict:from_list(Binding),
-  case orddict:find('_@MODULE', Keyword) of
-    { ok, _ } -> Keyword;
-    _ -> orddict:store('_@MODULE', nil, Keyword)
-  end.
@@ -1,164 +0,0 @@
-module(elixir_aliases).
-export([nesting_alias/2, last/1, concat/1, safe_concat/1,
-  format_error/1, ensure_loaded/3, ensure_loaded/4, expand/3, store/4]).
-include("elixir.hrl").
-
-%% Store an alias in the given scope
-store(_Meta, New, New, S) -> S;
-store(Meta, New, Old, S) ->
-  SA = S#elixir_scope{
-    aliases=orddict:store(New, Old, S#elixir_scope.aliases)
-  },
-
-  case lists:keymember(context, 1, Meta) of
-    true ->
-      SA#elixir_scope{
-        macro_aliases=orddict:store(New, Old, S#elixir_scope.macro_aliases)
-      };
-    false ->
-      SA
-  end.
-
-%% Expand an alias. It returns an atom (meaning that there
-%% was an expansion) or a list of atoms.
-
-expand({ '__aliases__', Meta, _ } = Alias, Aliases, MacroAliases) ->
-  case lists:keyfind(alias, 1, Meta) of
-    { alias, false } ->
-      expand(Alias, MacroAliases);
-    { alias, Atom } when is_atom(Atom) ->
-      case expand(Alias, MacroAliases) of
-        OtherAtom when is_atom(OtherAtom) -> OtherAtom;
-        OtherAliases when is_list(OtherAliases) -> Atom
-      end;
-    false ->
-      expand(Alias, Aliases)
-  end.
-
-expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
-  case expand_one(H, Aliases) of
-    false -> [H];
-    Atom  -> Atom
-  end;
-
-expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
-  case H of
-    'Elixir' ->
-      concat(T);
-    _ ->
-      case expand_one(H, Aliases) of
-        false -> [H|T];
-        Atom  -> concat([Atom|T])
-      end
-  end;
-
-expand({ '__aliases__', _Meta, List }, _Aliases) ->
-  List.
-
-expand_one(H, Aliases) ->
-  Lookup = list_to_atom("Elixir." ++ atom_to_list(H)),
-  case lookup(Lookup, Aliases) of
-    Lookup -> false;
-    Else   -> Else
-  end.
-
-%% Ensure a module is loaded before its usage.
-
-ensure_loaded(Line, Ref, S) ->
-  ensure_loaded(Line, S#elixir_scope.file, Ref, S#elixir_scope.context_modules).
-
-ensure_loaded(_Line, _File, 'Elixir.Kernel', _FileModules) ->
-  ok;
-
-ensure_loaded(Line, File, Ref, FileModules) ->
-  try
-    Ref:module_info(compile)
-  catch
-    error:undef ->
-      Kind = case lists:member(Ref, FileModules) of
-        true  -> scheduled_module;
-        false -> unloaded_module
-      end,
-      elixir_errors:form_error(Line, File, ?MODULE, { Kind, Ref })
-  end.
-
-%% Receives an atom and returns the last bit as an alias.
-
-last(Atom) ->
-  Last = last(lists:reverse(atom_to_list(Atom)), []),
-  list_to_atom("Elixir." ++ Last).
-
-last([$.|_], Acc) -> Acc;
-last([H|T], Acc) -> last(T, [H|Acc]);
-last([], Acc) -> Acc.
-
-%% Gets two modules names and return an alias
-%% which can be passed down to the alias directive
-%% and it will create a proper shortcut representing
-%% the given nesting.
-%%
-%% Examples:
-%%
-%%     nesting_alias('Elixir.Foo.Bar', 'Elixir.Foo.Bar.Baz.Bat')
-%%     { 'Elixir.Baz', 'Elixir.Foo.Bar.Baz' }
-%%
-%% When passed to alias, the example above will generate an
-%% alias like:
-%%
-%%     'Elixir.Baz' => 'Elixir.Foo.Bar.Baz'
-%%
-nesting_alias(nil, _Full) -> false;
-
-nesting_alias(Prefix, Full) ->
-  PrefixList = list_nesting(Prefix),
-  FullList   = list_nesting(Full),
-  (PrefixList /= []) andalso do_nesting(PrefixList, FullList, []).
-
-do_nesting([X|PreTail], [X|Tail], Acc) ->
-  do_nesting(PreTail, Tail, [X|Acc]);
-do_nesting([], [H|_], Acc) ->
-  { list_to_atom("Elixir." ++ H), concat(lists:reverse([H|Acc])) };
-do_nesting(_, _, _Acc) ->
-  false.
-
-list_nesting(Atom) ->
-  case string:tokens(atom_to_list(Atom), ".") of
-    ["Elixir"|T] -> T;
-    _ -> []
-  end.
-
-%% Receives a list of atoms, binaries or lists
-%% representing modules and concatenates them.
-
-concat(Args) -> list_to_atom(raw_concat(Args)).
-safe_concat(Args) -> list_to_existing_atom(raw_concat(Args)).
-
-raw_concat(['Elixir'|Args]) -> do_concat(Args);
-raw_concat(Args)            -> do_concat(Args).
-
-do_concat(Args) ->
-  Aliases = [to_partial(Arg) || Arg <- Args],
-  "Elixir" ++ lists:concat(Aliases).
-
-to_partial(Arg) when is_binary(Arg) -> to_partial(binary_to_list(Arg));
-to_partial(Arg) when is_atom(Arg)   -> to_partial(atom_to_list(Arg));
-to_partial("Elixir." ++ Arg)        -> [$.|Arg];
-to_partial([$.|_] = Arg)            -> Arg;
-to_partial(Arg) when is_list(Arg)   -> [$.|Arg].
-
-%% Lookup an alias in the current scope.
-
-lookup(Else, Dict) ->
-  case orddict:find(Else, Dict) of
-    { ok, Value } when Value /= Else -> lookup(Value, Dict);
-    _ -> Else
-  end.
-
-%% Errors
-
-format_error({unloaded_module, Module}) ->
-  io_lib:format("module ~ts is not loaded and could not be found", [elixir_errors:inspect(Module)]);
-
-format_error({scheduled_module, Module}) ->
-  io_lib:format("module ~ts is not loaded but was defined. This happens because you are trying to use a module in the same context it is defined. Try defining the module outside the context that requires it.",
-    [elixir_errors:inspect(Module)]).
@@ -1,258 +0,0 @@
-%% Handle code related to args, guard and -> matching for case,
-%% fn, receive and friends. try is handled in elixir_try.
-module(elixir_clauses).
-export([
-  assigns/3, assigns_block/5, assigns_block/6, extract_last_guards/1,
-  get_pairs/4, get_pairs/5, match/3, extract_args/1, extract_guards/1]).
-include("elixir.hrl").
-
-%% Get pairs from a clause.
-
-get_pairs(Meta, Key, Clauses, S) ->
-  get_pairs(Meta, Key, Clauses, S, false).
-
-get_pairs(Meta, Key, Clauses, S, AllowNil) ->
-  case lists:keyfind(Key, 1, Clauses) of
-    { Key, { '->', _, Pairs } } ->
-      [{ Key, Left, Right } || { Left, Right } <- Pairs];
-    { Key, nil } when AllowNil ->
-      [];
-    { Key, _ } ->
-      elixir_errors:syntax_error(Meta, S#elixir_scope.file, "expected pairs with -> for key ~ts", [Key]);
-    _ ->
-      []
-  end.
-
-% Function for translating assigns.
-
-assigns(Fun, Args, #elixir_scope{context=Context} = S) when Context /= match ->
-  { Result, NewS } = assigns(Fun, Args, S#elixir_scope{context=match, temp_vars=orddict:new()}),
-  { Result, NewS#elixir_scope{context=Context} };
-
-assigns(Fun, Args, S) -> Fun(Args, S).
-
-%% Function for translating a block that is preceeded by an
-%% assignment and optional guards. This is used by def* and fn.
-
-assigns_block(Line, Fun, BareArgs, Exprs, S) ->
-  { Args, Guards } = extract_guards(BareArgs),
-  assigns_block(Line, Fun, Args, Exprs, Guards, S).
-
-assigns_block(Line, Fun, Args, Exprs, Guards, S) when is_integer(Line) ->
-  { TArgs, SA }  = assigns(Fun, Args, S#elixir_scope{extra_guards=[]}),
-  { TExprs, SE } = elixir_translator:translate(Exprs, SA#elixir_scope{extra_guards=nil}),
-
-  FArgs   = listify(TArgs),
-  SG      = SA#elixir_scope{context=guard, extra_guards=nil},
-  Extra   = SA#elixir_scope.extra_guards,
-
-  FGuards = case Guards of
-    [] -> case Extra of [] -> []; _ -> [Extra] end;
-    _  -> [translate_guard(Line, Guard, Extra, SG) || Guard <- Guards]
-  end,
-
-  % Uncompact expressions from the block.
-  case TExprs of
-    [{ block, _, FExprs }] -> [];
-    _ -> FExprs = TExprs
-  end,
-
-  { { clause, Line, FArgs, FGuards, FExprs }, SE }.
-
-% Translate/Extract guards from the given expression.
-
-translate_guard(Line, Guard, Extra, S) ->
-  [element(1, elixir_translator:translate_each(elixir_quote:linify(Line, Guard), S))|Extra].
-
-extract_guards({ 'when', _, [Left, Right] }) -> { Left, extract_or_clauses(Right, []) };
-extract_guards(Else) -> { Else, [] }.
-
-extract_or_clauses({ 'when', _, [Left, Right] }, Acc) -> extract_or_clauses(Right, [Left|Acc]);
-extract_or_clauses(Term, Acc) -> [Term|Acc].
-
-% Extract name and args from the given expression.
-
-extract_args({ { '.', _, [Name] }, _, Args }) when is_atom(Name), is_list(Args) -> { Name, Args };
-extract_args({ Name, _, Args }) when is_atom(Name), is_atom(Args) -> { Name, [] };
-extract_args({ Name, _, Args }) when is_atom(Name), is_list(Args) -> { Name, Args };
-extract_args(_) -> error.
-
-% Extract guards when it is in the last element of the args
-
-extract_last_guards([]) -> { [], [] };
-extract_last_guards(Args) ->
-  { Left, Right }  = elixir_tree_helpers:split_last(Args),
-  { Bare, Guards } = extract_guards(Right),
-  { Left ++ [Bare], Guards }.
-
-% Function for translating macros with match style like case and receive.
-
-match(Meta, Clauses, #elixir_scope{clause_vars=C1} = S) ->
-  { TC, TS } = do_match(Meta, Clauses, S#elixir_scope{clause_vars=orddict:new()}),
-  C2 = TS#elixir_scope.clause_vars,
-  { TC, TS#elixir_scope{clause_vars=elixir_scope:merge_clause_vars(C1, C2)} }.
-
-do_match(_Meta, [], S) ->
-  { [], S };
-
-do_match(Meta, [DecoupledClause], S) ->
-  { TDecoupledClause, TS } = each_clause(Meta, DecoupledClause, S),
-  { [TDecoupledClause], TS };
-
-do_match(Meta, DecoupledClauses, S) ->
-  % Transform tree just passing the variables counter forward
-  % and storing variables defined inside each clause.
-  Transformer = fun(X, {Acc, CV}) ->
-    { TX, TAcc } = each_clause(Meta, X, Acc),
-    { TX, { merge_clauses_scope(S, TAcc), [TAcc#elixir_scope.clause_vars|CV] } }
-  end,
-
-  { TClauses, { TS, ReverseCV } } = lists:mapfoldl(Transformer, {S, []}, DecoupledClauses),
-
-  % Now get all the variables defined inside each clause
-  CV = lists:reverse(ReverseCV),
-  AllVars = lists:foldl(fun(KV, Acc) ->
-    elixir_scope:merge_clause_vars(Acc, KV)
-  end, orddict:new(), CV),
-
-  % Create a new scope that contains a list of all variables
-  % defined inside all the clauses. It returns this new scope and
-  % a list of tuples where the first element is the variable name,
-  % the second one is the new pointer to the variable and the third
-  % is the old pointer.
-  { FinalVars, FS } = lists:mapfoldl(fun({ Key, Ref }, Acc) ->
-    normalize_vars(Key, Ref, Acc)
-  end, TS, AllVars),
-
-  % Expand all clauses by adding a match operation at the end
-  % that assigns variables missing in one clause to the others.
-  expand_clauses(?line(Meta), TClauses, CV, FinalVars, [], FS).
-
-expand_clauses(Line, [Clause|T], [ClauseVars|V], FinalVars, Acc, S) ->
-  case generate_match_vars(FinalVars, ClauseVars, [], []) of
-    { [], [] } ->
-      expand_clauses(Line, T, V, FinalVars, [Clause|Acc], S);
-    { Left, Right } ->
-      MatchExpr   = generate_match(Line, Left, Right),
-      ClauseExprs = element(5, Clause),
-      [Final|RawClauseExprs] = lists:reverse(ClauseExprs),
-
-      % If the last sentence has a match clause, we need to assign its value
-      % in the variable list. If not, we insert the variable list before the
-      % final clause in order to keep it tail call optimized.
-      { FinalClauseExprs, FS } = case has_match_tuple(Final) of
-        true ->
-          case Final of
-            { match, _, { var, _, UserVarName } = UserVar, _ } when UserVarName /= '_' ->
-              { [UserVar,MatchExpr,Final|RawClauseExprs], S };
-            _ ->
-              { StorageVar, SS } = elixir_scope:build_erl_var(Line, S),
-              StorageExpr = { match, Line, StorageVar, Final },
-              { [StorageVar,MatchExpr,StorageExpr|RawClauseExprs], SS }
-          end;
-        false ->
-          { [Final,MatchExpr|RawClauseExprs], S }
-      end,
-
-      FinalClause = setelement(5, Clause, lists:reverse(FinalClauseExprs)),
-      expand_clauses(Line, T, V, FinalVars, [FinalClause|Acc], FS)
-  end;
-
-expand_clauses(_Line, [], [], _FinalVars, Acc, S) ->
-  { lists:reverse(Acc), S }.
-
-% Handle each key/value clause pair and translate them accordingly.
-
-each_clause(Meta, { do, [Condition], Expr }, S) ->
-  assigns_block(?line(Meta), fun elixir_translator:translate_each/2, Condition, [Expr], S);
-
-each_clause(Meta, { else, [Condition], Expr }, S) ->
-  assigns_block(?line(Meta), fun elixir_translator:translate_each/2, Condition, [Expr], S);
-
-each_clause(Meta, { 'after', [Condition], Expr }, S) ->
-  { TCondition, SC } = elixir_translator:translate_each(Condition, S),
-  { TBody, SB } = elixir_translator:translate([Expr], SC),
-  { { clause, ?line(Meta), [TCondition], [], TBody }, SB };
-
-each_clause(Meta, { Key, [_|_], _ }, S) when Key == do; Key == 'after' ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "too many arguments given for ~ts", [Key]);
-
-each_clause(Meta, { Key, _, _ }, S) ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file, "invalid key ~ts", [Key]).
-
-% Check if the given expression is a match tuple.
-% This is a small optimization to allow us to change
-% existing assignments instead of creating new ones every time.
-
-has_match_tuple({'receive', _, _, _, _}) ->
-  true;
-
-has_match_tuple({'receive', _, _}) ->
-  true;
-
-has_match_tuple({'case', _, _, _}) ->
-  true;
-
-has_match_tuple({match, _, _, _}) ->
-  true;
-
-has_match_tuple(H) when is_tuple(H) ->
-  has_match_tuple(tuple_to_list(H));
-
-has_match_tuple(H) when is_list(H) ->
-  lists:any(fun has_match_tuple/1, H);
-
-has_match_tuple(_) -> false.
-
-% Normalize the given var in between clauses
-% by picking one value as reference and retriving
-% its previous value.
-
-normalize_vars(Key, Value, #elixir_scope{vars=Vars,clause_vars=ClauseVars} = S) ->
-  FS = S#elixir_scope{
-    vars=orddict:store(Key, Value, Vars),
-    clause_vars=orddict:store(Key, Value, ClauseVars)
-  },
-
-  Expr = case orddict:find(Key, Vars) of
-    { ok, OldValue } -> { var, 0, OldValue };
-    error -> { atom, 0, nil }
-  end,
-
-  { { Key, Value, Expr }, FS }.
-
-% Generate match vars by checking if they were updated
-% or not and assigning the previous value.
-
-generate_match_vars([{ Key, NewValue, OldValue }|T], ClauseVars, Left, Right) ->
-  case orddict:find(Key, ClauseVars) of
-    { ok, NewValue } ->
-      generate_match_vars(T, ClauseVars, Left, Right);
-    { ok, ClauseValue } ->
-      generate_match_vars(T, ClauseVars, [{ var, 0, NewValue }|Left], [{ var, 0, ClauseValue }|Right]);
-    error ->
-      generate_match_vars(T, ClauseVars, [{ var, 0, NewValue }|Left], [OldValue|Right])
-  end;
-
-generate_match_vars([], _ClauseVars, Left, Right) ->
-  { Left, Right }.
-
-generate_match(Line, [Left], [Right]) ->
-  { match, Line, Left, Right };
-
-generate_match(Line, LeftVars, RightVars) ->
-  { match, Line, { tuple, Line, LeftVars }, { tuple, Line, RightVars } }.
-
-listify(Expr) when not is_list(Expr) -> [Expr];
-listify(Expr) -> Expr.
-
-%% We don't use umergec because imports, aliases and
-%% what not are not passed from one clause to the other.
-merge_clauses_scope(S1, S2) ->
-  S1#elixir_scope{
-    counter=S2#elixir_scope.counter,
-    extra_guards=S2#elixir_scope.extra_guards,
-    super=S1#elixir_scope.super orelse S2#elixir_scope.super,
-    caller=S1#elixir_scope.caller orelse S2#elixir_scope.caller,
-    name_args=S1#elixir_scope.name_args orelse S2#elixir_scope.name_args
-  }.
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
hermes-agent	c345dab9c1	Merge pull request 'adapter: support OpenAI streaming (SSE) in /v1/chat/completions' (#1 ) from feat/adapter-streaming into main	2026-09-12 12:51:34 +02:00
hermes-agent	2d46eda619	adapter: support OpenAI streaming (SSE) in /v1/chat/completions 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.	2026-09-12 10:50:47 +00:00
hermes-agent	beb9b1b3ef	Add temporary chat-request logging (diagnose SwiftChat error)	2026-09-11 18:44:45 +00:00
hermes-agent	cb512a7f17	admin: serve the page without requiring the Bearer header A browser opening /admin can't send an Authorization header, so the admin page was unreachable (401 blank). Serve the HTML form openly — it exposes no data — and let the in-page ADMIN_API_KEY field drive the auth'd /admin/agents CRUD calls.	2026-09-11 15:36:15 +00:00
hermes-agent	e4fdeb6b79	nixos-module: set RELEASE_COOKIE so the release starts The Elixir release's start script reads releases/COOKIE which isn't baked in, so the service crashed on boot (cat: releases/COOKIE: No such file). Set RELEASE_COOKIE in the systemd Environment to fix startup.	2026-09-10 14:35:28 +00:00
hermes-agent	6b22171018	flake: fill mixFodDeps hash	2026-09-10 07:21:42 +00:00
hermes-agent	f0112289e6	flake: add mixFodDeps (fetchMixDeps) for Hex deps	2026-09-10 07:17:56 +00:00
hermes-agent	72e18a0a0c	Remove AGENTS env seeding; agents managed only via admin API The store now starts empty and agents are added/removed exclusively through the web admin page / admin API, persisted to AGENTS_FILE. No AGENTS env var needed in the sops secret.	2026-09-10 07:06:26 +00:00
hermes-agent	e2be3f652e	Add web admin page to manage agents GET /admin serves a self-contained HTML page (ADMIN_API_KEY protected) that lists agents and lets you add/update/remove them via the admin API — no redeploy needed to add an agent.	2026-09-10 06:59:08 +00:00
hermes-agent	490bd32322	Add admin API to manage agents at runtime - AgentRegistry is now file-backed (AGENTS_FILE, default /var/lib/n8n-openai/agents.json): agents persist across restarts and can be added/removed without a redeploy. - New admin endpoints (separate ADMIN_API_KEY): GET /admin/agents POST /admin/agents {model, webhook} DELETE /admin/agents/:model - AGENTS env only seeds the store on first boot; the file is authoritative. - NixOS module sets AGENTS_FILE under the writable StateDirectory.	2026-09-10 06:46:05 +00:00
hermes-agent	1bfcba133a	Add NixOS module for the adapter service Export nixosModules.default so the service (systemd unit, service user, sops secret) is defined in the flake, not re-declared in each host config. Consume with imports = [ inputs.n8n-openai-adapter.nixosModules.default ] + services.n8n-openai-adapter = { enable = true; domain = ...; port = ...; }.	2026-09-10 06:36:44 +00:00
hermes-agent	c3d024c16c	Apply mix format	2026-09-09 21:46:16 +00:00
hermes-agent	1530a761d5	Add flake.lock pinning nixpkgs	2026-09-09 21:44:55 +00:00
hermes-agent	5197b6ece6	OpenAI-compatible adapter for n8n chat agents (Elixir) Exposes self-hosted n8n chat agents behind /v1/chat/completions and /v1/models. Model -> n8n webhook routing via a GenServer registry, so multiple agents map to multiple models. Plug + Bandit, req for the n8n webhook call, Bearer auth (ADAPTER_API_KEY). Ships a flake.nix (beamPackages.mixRelease) so it can be consumed as a NixOS flake input.	2026-09-09 21:43:21 +00:00